# fivemad.com RedM documentation
> Free tools, game data and documentation for RedM (Red Dead Redemption 2 on Cfx.re) server owners and developers.
> This file holds every RedM documentation page in full. The short map is at https://fivemad.com/redm/llms.txt.
> Any single page is available on its own: add .md to its URL.
# AI and API
## Using fivemad RedM with an AI assistant
URL: https://fivemad.com/redm/docs/ai
Read any RedM docs page as Markdown, hand a page to ChatGPT, Claude or Cursor in one click, and point an assistant at the whole RedM side with /redm/llms.txt.
Everything on the RedM side of fivemad is public and free, including for a machine. You do not need a key, an account or a contract.
This page is for the reader who wants an assistant to know about RedM on this site: how it reads these docs and how to hand it a page. If you want to call our RDR2 data from your own code instead, that is the [RedM API](/redm/docs/ai/api), with request and response examples in Lua, JavaScript, Python and curl.
If you are the assistant reading this: start at [/redm/llms.txt](/redm/llms.txt).
## Why it matters more on RedM
An assistant trained mostly on FiveM code will happily write GTA V natives, control numbers and model names into a RedM script. None of them work on RDR2. Giving it the right page first (the [porting checklist](/redm/docs/porting), the [fxmanifest](/redm/docs/getting-started/fxmanifest) with the exact `rdr3_warning` line) is the difference between code that starts and code that does not.
## Read any docs page as Markdown
Add `.md` to any `/redm/docs` URL and you get the page as plain Markdown with a `text/markdown` content type.
```txt
https://fivemad.com/redm/docs/getting-started/fxmanifest the page
https://fivemad.com/redm/docs/getting-started/fxmanifest.md the same page as Markdown
https://fivemad.com/redm/docs.md the index of every RedM page
```
The Markdown is the real source of the page. The first lines say where it came from, which section it belongs to and when it was last touched, so a model that only sees the file still knows what it is holding.
```bash
curl https://fivemad.com/redm/docs/getting-started/fxmanifest.md
```
```md
> Source: https://fivemad.com/redm/docs/getting-started/fxmanifest
> Section: Getting started
> Tags: fxmanifest, rdr3_warning, game, rdr3, fx_version, lua54
> Last updated: 2026-10-01
> Site map for assistants: https://fivemad.com/redm/llms.txt
# The fxmanifest and rdr3_warning
A RedM resource declares game 'rdr3' and carries the rdr3_warning line word for word, or it does not start. A minimal manifest you can copy.
Every resource has an `fxmanifest.lua` in its root folder. On RedM it is the same file as on FiveM with two differences...
```
## Hand one page over: the Open menu
Every docs page has an **Open** button next to the breadcrumbs. It gives you:
- **View as Markdown**, the `.md` file above.
- **Copy as Markdown**, the same text straight to your clipboard, for pasting into a chat.
- **Open in ChatGPT**, **Open in Claude**, **Open in Cursor**: a new conversation that already asks the assistant to read this page's `.md` URL.
The "open in" entries pass the URL rather than the text, so the assistant fetches the current page instead of working from a copy that ages.
> [!TIP]
> In an agent that can browse (Claude Code, Cursor, Codex and friends) you rarely need the menu. Say "read https://fivemad.com/redm/llms.txt" once at the start and it can find the rest on its own.
## /redm/llms.txt and /redm/llms-full.txt
| File | What it holds |
| --- | --- |
| [/redm/llms.txt](/redm/llms.txt) | The short map: what the RedM side is, every RedM tool with one line, the whole RedM docs tree, every RDR2 dataset with its row count and size, and the API. |
| [/redm/llms-full.txt](/redm/llms-full.txt) | The RedM documentation itself, every page in full, in one plain text file. |
Both are built from the same tool registry and the same data files the site ships, so the counts in them are real. Every RedM docs page carries `/redm/llms.txt` as a `` in its head. The FiveM side has its own pair at [/llms.txt](/llms.txt) and [/llms-full.txt](/llms-full.txt); the two do not overlap.
```bash
curl https://fivemad.com/redm/llms.txt
```
```txt
# fivemad.com RedM
> Free tools, game data and documentation for RedM (Red Dead Redemption 2 on Cfx.re) server owners and developers.
> 19 browser tools, 30 documentation pages and 19 public datasets read from RDR2's own game files.
> Nothing here needs an account. The tools run in the browser; the data below is static files you can fetch directly.
> The FiveM (GTA V) side of the site has its own map: https://fivemad.com/llms.txt
## How to use this site as an assistant
- Add .md to any RedM docs URL for the plain Markdown source: https://fivemad.com/redm/docs/getting-started/fxmanifest.md
- Whole RedM documentation in one file: https://fivemad.com/redm/llms-full.txt
- Dataset index with row counts and sizes: https://fivemad.com/redm/data/index.json
- Search RedM tools, docs and datasets: https://fivemad.com/api/redm/search?q=prompt
- Look up an RDR2 joaat hash: https://fivemad.com/api/redm/hash?q=0xC8DA3400
- Search RDR2's English game text: https://fivemad.com/api/redm/text?q=saloon
...
## Datasets
- [Ped models](https://fivemad.com/data/rdr3/peds.json): Every ped model of RDR2 (people, horses, animals, fish)
with its outfit count and a category read from the name. (1,983 rows, 150 KB; columns + rows: [model, hash,
hash_signed, category, outfits, label, name_source, town_sets])
```
Every count in that file is read off the real registry and the real files when the site is built, so the numbers above are whatever they were the day this page was written, and the live file is always current.
> [!TIP]
> If you are pasting context into a chat by hand, `/redm/llms.txt` plus the two or three `.md` pages it points at is almost always better than `/redm/llms-full.txt`. The full file is large.
The machine readable version of the dataset list, with the row shape and the real byte size of every file, is [`/redm/data/index.json`](/redm/data/index.json), which the [API page](/redm/docs/ai/api) walks through.
## What an assistant can and cannot do here
It can:
- read any RedM docs page as Markdown, and the whole set at once;
- list and download every RDR2 dataset, with the row shape given up front;
- check whether an RDR2 name is real and get its hash, or turn a hash back into a name;
- find a line of RDR2's own game text by words, label hash or key;
- link you straight to the page that shows the same thing.
The last three are HTTP calls rather than reading, so they live on the [API page](/redm/docs/ai/api).
It cannot:
- run the tools that need your files or a browser. The map tools, the Map Editor, the Blip Replacer, Folders to YTD, the Photo Mode Converter and the Resource Conflict Checker all work on data in your own browser, and there is no upload endpoint for them.
- write anything. Everything here is read only from the outside.
- name what we do not have. RDR2 stores most of its names only as hashes, so plenty of real values have no known name, and a model or label that a custom resource adds is not in our data at all.
- be treated as a live game API. Nothing here talks to a running RedM server.
## Keeping an assistant honest
Ask it for the URL it used. Every answer here has a page behind it, and both the `.md` files and the API answers carry a link back, so "where did that come from" always has an answer. If it cannot give you one, it made it up.
Check anything with a hash or a name in it. On RedM this matters twice over, because a GTA V name pasted into a RedM script looks right and does nothing. Paste it into the [Hash Calculator](/redm/tools/hash-calculator), or call `/api/redm/hash` yourself ([how](/redm/docs/ai/api#look-up-a-joaat-hash)) and see whether RDR2 really has that name.
_Last updated: 2026-10-01_
---
## RedM API
URL: https://fivemad.com/redm/docs/ai/api
Look up RDR2 joaat hashes, search RDR2's game text, search the RedM docs and fetch the RedM datasets over plain HTTP, with examples in Lua, JavaScript, Python and curl.
The data behind the RedM tools is reachable over HTTP. There is no key, no account and no quota to apply for. **Every endpoint is a plain `GET` with query parameters**, so anything that can fetch a URL can use it: a RedM resource, a build script, your editor, or an assistant you pointed at [/redm/llms.txt](/redm/llms.txt).
If what you want is for ChatGPT, Claude or Cursor to read these docs, that is the other page: [using fivemad RedM with an AI assistant](/redm/docs/ai).
| What | Where |
| --- | --- |
| Every RedM dataset, with its row shape and size | [`/redm/data/index.json`](/redm/data/index.json) |
| joaat hash of an RDR2 name, both directions | `/api/redm/hash?q=` |
| RDR2's English game text | `/api/redm/text?q=` |
| Search RedM tools, docs and datasets | `/api/redm/search?q=` |
The FiveM (GTA V) endpoints are documented separately on the [FiveM API page](/docs/ai/api). The two sets share their rate limits, see [Rate limits](#rate-limits).
## Calling it
One call, four ways. After this section the examples use the shortest form that makes the point, because the request is always just a URL.
### Lua, inside a resource
`PerformHttpRequest` is a server side native and works the same on RedM as on FiveM. The callback gets `(status, body, headers)`, where `status` is the HTTP status code (or `0` when the request never got out) and `body` is the raw response text, so it needs `json.decode`.
```lua title="server.lua"
local API = "https://fivemad.com/api/redm"
--- Look up an RDR2 hash or name. cb(result) gets one entry of `results`, or nil.
local function lookupHash(query, cb)
local url = ("%s/hash?q=%s"):format(API, query)
PerformHttpRequest(url, function(status, body, headers)
if status ~= 200 then
print(("[fivemad] lookup failed, HTTP %s"):format(status))
return cb(nil)
end
local data = json.decode(body)
cb(data and data.results and data.results[1] or nil)
end, "GET")
end
RegisterCommand("rdrhash", function(source, args)
lookupHash(args[1] or "", function(r)
if not r then return end
print(("[fivemad] %s -> %d match(es)"):format(r.query, r.matchCount))
for _, m in ipairs(r.matches) do
print((" %s %s"):format(m.name, m.kindLabel))
end
end)
end, true)
```
> [!WARNING]
> Call this from a command, an admin tool or a one off script, and cache what you get. Do not put it in a tick, a loop over every entity or anything that runs per player: it is a documentation API, not a game service, and the rate limits below are real. If you need a lookup on the hot path, fetch the dataset once at resource start and keep the table in memory.
### JavaScript, in the browser or in Node
The `/api/redm/*` endpoints send `access-control-allow-origin: *`, so this works from a page as well as from Node.
```js title="lookup.mjs"
const API = "https://fivemad.com/api/redm";
const res = await fetch(`${API}/hash?q=0xC8DA3400`);
const data = await res.json();
for (const m of data.results[0].matches) console.log(m.name, m.kind);
```
```txt
a_c_horse_arabian_white ped
```
### Python
Nothing to install; the standard library is enough.
```py title="lookup.py"
import json, urllib.request
API = "https://fivemad.com/api/redm"
with urllib.request.urlopen(f"{API}/hash?q=0xC8DA3400") as r:
data = json.load(r)
for m in data["results"][0]["matches"]:
print(m["name"], m["kind"])
```
```txt
a_c_horse_arabian_white ped
```
### curl
```bash
curl "https://fivemad.com/api/redm/hash?q=0xC8DA3400"
```
All four get the same answer:
```json
{
"game": "rdr3",
"build": "1.0.1491.50",
"query": "0xC8DA3400",
"searched": {
"names": 28747,
"sets": 17,
"byKind": {
"ped": 1982, "weapon": 137, "ammo": 69, "vehicle": 115, "blip": 628, "blipStyle": 620,
"control": 373, "promptHold": 8, "scenario": 2666, "timecycle": 1286, "weather": 22,
"zone": 87, "interior": 278, "imap": 5124, "script": 1889, "item": 13085, "document": 378
}
},
"note": "joaat is a 32 bit hash, so a value can belong to more than one name. Every match is listed; none is picked for you. A label match is the game's own English text stored under that hash.",
"limit": "60 requests per minute per IP",
"count": 1,
"results": [
{
"query": "0xC8DA3400",
"readAs": "hash",
"hash": { "unsigned": 3369743360, "signed": -925223936, "hex": "0xC8DA3400" },
"matchCount": 1,
"matches": [
{
"name": "a_c_horse_arabian_white",
"kind": "ped",
"kindLabel": "Ped model",
"page": "https://fivemad.com/redm/assets?t=peds&q=a_c_horse_arabian_white"
}
]
}
]
}
```
## The datasets
The RDR2 data behind the RedM tools is a set of static files under `/data/rdr3`. It is the same file the tool itself fetches, so nothing is held back. Start with the index, which is generated from the real files:
```bash
curl https://fivemad.com/redm/data/index.json
```
```json
{
"site": "https://fivemad.com/redm",
"game": "rdr3",
"generated": "2026-10-01",
"docs": "https://fivemad.com/redm/docs/ai/api",
"llms": "https://fivemad.com/redm/llms.txt",
"count": 19,
"totalBytes": 8435812,
"datasets": [
{
"id": "rdr3-peds",
"title": "Ped models",
"url": "https://fivemad.com/data/rdr3/peds.json",
"about": "Every ped model of RDR2 (people, horses, animals, fish) with its outfit count and a category read from the name.",
"shape": "columns + rows: [model, hash, hash_signed, category, outfits, label, name_source, town_sets]",
"rows": 1983,
"bytes": 153371,
"size": "150 KB",
"page": "https://fivemad.com/redm/assets?t=peds",
"pageName": "RedM Assets"
}
]
}
```
Each entry gives the URL, what the file holds, how a row is laid out, how many rows there are and how big the download is. Most files carry a `columns` array and `rows` of short arrays in that order, so read a row by column name, not by position. Every hashed file also stores the hash twice: `hash` unsigned, and `hash_signed`, the same bits as a signed int, which is what `GetHashKey` returns.
The largest is the game text, 259,297 labels in a 3.8 MB brotli file. Do not download it to look up one line: use [`/api/redm/text`](#game-text) instead.
Loading a dataset once at resource start is the right pattern for a server:
```lua title="server.lua"
local peds = nil
CreateThread(function()
PerformHttpRequest("https://fivemad.com/data/rdr3/peds.json", function(status, body)
if status ~= 200 then return end
local data = json.decode(body)
peds = {}
for _, row in ipairs(data.rows) do
local r = {}
for i, col in ipairs(data.columns) do r[col] = row[i] end
peds[r.model] = r -- 1,983 rows, about 150 KB
end
end, "GET")
end)
```
> [!NOTE]
> These files change when we rebuild them from the game, not per request. On a server you restart often, ship the file with your resource instead and update it when you feel like it.
## Look up a joaat hash
`/api/redm/hash` takes a hash or a name. A number is looked up in every RDR2 name set we read from the game's files, plus the game's English text by label hash; a name is hashed and looked up the same way, so the answer also says whether RDR2 really has that name. Today that is 28,747 names in 17 sets, and `searched.byKind` in every answer lists them with their counts.
- `q` accepts an unsigned value, a signed int32, `0x` hex, or a name. Up to 25 values in one call, separated by commas or new lines.
- `kind` narrows the matches, for example `kind=ped,vehicle`. The kinds are `ped`, `weapon`, `ammo`, `vehicle`, `blip`, `blipStyle`, `control`, `promptHold`, `scenario`, `timecycle`, `weather`, `zone`, `interior`, `imap`, `script`, `item`, `document` and `label` (a game text label).
- A name comes back with its unsigned, signed and hex forms and the Lua backtick literal.
> [!IMPORTANT]
> joaat is a 32 bit hash, so a value can belong to more than one name. Every match is returned and none is picked for you. When `matchCount` is above 1, decide from context.
A real one: `INPUT_JUMP` is both a control and the key of a game text label, so both come back:
```bash
curl "https://fivemad.com/api/redm/hash?q=INPUT_JUMP"
```
```json
{
"results": [
{
"query": "INPUT_JUMP",
"readAs": "name",
"name": "INPUT_JUMP",
"lua": "`input_jump`",
"hash": { "unsigned": 3654345152, "signed": -640622144, "hex": "0xD9D0E1C0" },
"matchCount": 2,
"matches": [
{
"name": "INPUT_JUMP",
"kind": "control",
"kindLabel": "Control (input)",
"page": "https://fivemad.com/redm/assets?t=controls&q=INPUT_JUMP"
},
{
"name": "INPUT_JUMP",
"kind": "label",
"kindLabel": "Game text label: \"Jump\"",
"page": "https://fivemad.com/redm/tools/text-search?q=0xD9D0E1C0",
"text": "Jump"
}
]
}
]
}
```
With `kind=control` only the first match is left. Several controls at once, in Python:
```py title="controls.py"
import json, urllib.parse, urllib.request
API = "https://fivemad.com/api/redm"
names = ["INPUT_JUMP", "INPUT_ENTER", "INPUT_CONTEXT_Y"]
url = f"{API}/hash?" + urllib.parse.urlencode({"q": ",".join(names), "kind": "control"})
with urllib.request.urlopen(url) as r:
data = json.load(r)
for res in data["results"]:
print(res["name"], res["hash"]["hex"], res["hash"]["signed"], res["matchCount"])
```
```txt
INPUT_JUMP 0xD9D0E1C0 -640622144 1
INPUT_ENTER 0xCEFD9220 -822242784 1
INPUT_CONTEXT_Y 0xD51B784F -719620017 1
```
`matchCount: 0` means we have no record of that name or value, not that it does not exist: the game stores most of its names only as hashes, and a resource can add its own. The page for the same lookup is the [Hash Calculator](/redm/docs/tools/hash-calculator), under Reverse lookup.
## Game text
`/api/redm/text` searches RDR2's American English text: 259,297 labels, 183,520 of them spoken lines. The text stays on our server, so a call answers in a few hundred bytes instead of a 3.8 MB download.
| Parameter | What it does | Default |
| --- | --- | --- |
| `q` | At least two characters. Words (every word has to be in the line or its key name), a label hash (`0x0000F96B`, `63851`, 8 hex digits) or a label key. | required |
| `kind` | `all`, `dialogue` (spoken lines) or `ui` (everything else). | `all` |
| `limit` | Rows to return, 1 to 200. | 50 |
A query that reads as a hash or hashes to a label key is answered in `exact` first. The word search returns rows in label hash order, and `total` is the full count, not just what fits in `limit`.
```bash
curl "https://fivemad.com/api/redm/text?q=saloon&limit=3"
```
```json
{
"query": "saloon",
"kind": "all",
"game": "rdr3",
"build": "1.0.1491.50",
"searched": { "labels": 259297, "dialogue": 183520, "withKey": 27294 },
"exact": [],
"total": 294,
"count": 3,
"ms": 9,
"results": [
{
"hash": { "unsigned": 4324998, "signed": 4324998, "hex": "0x0041FE86" },
"key": "",
"text": "Bill, Micah and Sean are meeting the Grays over at the saloon about a job.",
"raw": "Bill, Micah and Sean are meeting the Grays over at the saloon about a job.",
"dialogue": false
},
{
"hash": { "unsigned": 35507793, "signed": 35507793, "hex": "0x021DCE51" },
"key": "BRT1_F_HARMOUTS",
"text": "The saloon staff were harmed.",
"raw": "The saloon staff were harmed.",
"dialogue": false
},
{
"hash": { "unsigned": 44939184, "signed": 44939184, "hex": "0x02ADB7B0" },
"key": "",
"text": "WANTED for the ATTEMPTED MURDER of well-liked saloon proprietor, Carl Evans, and the abduction of Mrs. Evans, who has since escaped CORBETT'S custody.",
"raw": "WANTED for the ATTEMPTED MURDER of well-liked saloon proprietor, Carl Evans, and the abduction of Mrs. Evans, who has since escaped CORBETT'S custody.",
"dialogue": false
}
]
}
```
`text` is the line made readable (`~n~` becomes a line break and the formatting codes go); `raw` is exactly what the game stores, markup included. `key` is the label's name when one is known, which is true for 27,294 labels; the rest are known only by hash.
By hash:
```bash
curl "https://fivemad.com/api/redm/text?q=0x0000F96B"
```
```json
{
"exact": [
{
"hash": { "unsigned": 63851, "signed": 63851, "hex": "0x0000F96B" },
"key": "",
"text": "Jumping Jeremiah!",
"raw": "~z~Jumping Jeremiah!",
"dialogue": true
}
],
"total": 0,
"count": 0,
"results": []
}
```
The `~z~` in front is how the game marks a spoken line. In JavaScript, spoken lines only:
```js title="text.mjs"
const API = "https://fivemad.com/api/redm";
const res = await fetch(`${API}/text?q=${encodeURIComponent("jumping jeremiah")}&kind=dialogue`);
const data = await res.json();
console.log(`${data.total} line(s) of ${data.searched.labels}`);
for (const r of data.results) console.log(r.hash.hex, r.text);
```
```txt
2 line(s) of 259297
0x0000F96B Jumping Jeremiah!
0xDC7DB265 Jumping Jeremiah.
```
The page for the same search, with the Lua to replace a line in RedM, is the [Game Text Search](/redm/docs/tools/text-search).
## Search
One short JSON answer over the RedM tools, the RedM docs and the RedM dataset index. It is the cheapest way for a script or an assistant to find out what exists without downloading anything.
```bash
curl "https://fivemad.com/api/redm/search?q=prompt&limit=3"
```
```json
{
"game": "rdr3",
"query": "prompt",
"type": "all",
"total": 10,
"returned": 3,
"limit": "60 requests per minute per IP",
"hint": "Add .md to any /redm/docs URL for the plain Markdown source.",
"results": [
{
"type": "doc",
"title": "Prompt Builder",
"url": "https://fivemad.com/redm/docs/tools/prompt-builder",
"markdown": "https://fivemad.com/redm/docs/tools/prompt-builder.md",
"summary": "Build a group of RDR2 prompts (press, hold or mash) on the game's own input actions and hold timings, try them in a preview, and download the Lua.",
"extra": {
"section": "Tools",
"match": "The Prompt Builder makes the \"press E to...\" boxes RDR2 shows in the bottom right of the screen. You set up a group of prompts, try each one in a preview that behaves like the real thing, and get a ready resource: a..."
},
"score": 117.5
},
{
"type": "tool",
"title": "Prompt Builder",
"url": "https://fivemad.com/redm/tools/prompt-builder",
"summary": "Build a group of RDR2 prompts (press, hold or mash) on the game's own controls and hold timings, preview it, and copy the Lua.",
"extra": { "group": "Generators" },
"score": 105
},
{
"type": "doc",
"title": "Porting a FiveM resource to RedM",
"url": "https://fivemad.com/redm/docs/porting",
"markdown": "https://fivemad.com/redm/docs/porting.md",
"summary": "What changes when a FiveM resource moves to RedM, in the order you hit it: the game key, natives by hash, controls, peds and outfits, prompts, blips and game data.",
"extra": {
"section": "Porting from FiveM",
"match": "hing, tell InvokeNative what to read back, the same way the Prompt Builder output does it: local N = Citizen.InvokeNative local p = N(0x04F97DE45A519419, Citizen.ResultAsInteger()) -- UI_PROMPT_REGISTER_BEGIN Go through..."
},
"score": 37.5
}
]
}
```
Parameters: `q` (required), `type` (`all`, `tools`, `docs`, `datasets`), `limit` (1 to 50, default 10). Every docs hit carries its `.md` URL, so the next step is one more fetch. The `score` only explains the order. `type=datasets` answers with the file URL, its shape and the page that uses it:
```bash
curl "https://fivemad.com/api/redm/search?q=doors&type=datasets"
```
```json
{
"results": [
{
"type": "dataset",
"title": "Doors",
"url": "https://fivemad.com/data/rdr3/doors.json",
"summary": "Every door RDR2 registers with its door system: door hash, model, position, heading and the interior it is in.",
"extra": {
"id": "rdr3-doors",
"shape": "columns + rows: [hashHex, hash, signed, model, modelHash, x, y, z, heading, interior, interiorName, script, copies]",
"page": "https://fivemad.com/redm/tools/door-finder"
},
"score": 90
}
]
}
```
## Rate limits
Per IP, in a fixed one minute window. The RedM endpoints draw from the same budgets as the FiveM ones:
| Endpoint | Budget | Limit |
| --- | --- | --- |
| `/api/redm/hash` | `hash`, shared with `/api/hash` | 60 per minute |
| `/api/redm/text` | `search`, shared with `/api/search` and `/api/redm/search` | 60 per minute |
| `/api/redm/search` | `search`, as above | 60 per minute |
| Every public API call, FiveM and RedM together | `all` | 240 per minute |
So 40 text searches and 20 RedM searches in one minute use up the `search` budget together. Over the limit you get `429` with a `retry-after` header in seconds and this body (a real one):
```json
{
"error": "rate_limited",
"message": "Too many requests. This endpoint allows 60 requests per minute per IP (240 across the whole API). Try again in 60s.",
"docs": "https://fivemad.com/redm/docs/ai/api"
}
```
The static files (`/redm/data/index.json`, `/data/rdr3/*`, the `.md` pages, `/redm/llms.txt`) are not rate limited. Please cache them rather than refetching.
## CORS, caching and errors
- The `/api/redm/*` endpoints answer with `access-control-allow-origin: *` and answer a preflight `OPTIONS` with `204`, so a browser based agent can call them from any page. `POST` with a JSON body works the same as the query string.
- A `200` answer is cached for 60 seconds (`cache-control: public, max-age=60`); an error is `no-store`.
- The static files are served by the front end web server, not by the app, so whether they carry a CORS header depends on the deployment. From `PerformHttpRequest`, curl or an assistant's own fetcher this makes no difference.
- Errors are JSON with an `error` code, a `message` written for a human, and a `docs` link. For a `/api/redm/*` call the link points at this page; the FiveM endpoints point at the [FiveM API page](/docs/ai/api).
| Status | `error` | When |
| --- | --- | --- |
| 400 | `invalid` | `q` is missing (or shorter than two characters on `/text`) |
| 400 | `bad_kind` | an unknown `kind` on `/hash` or `/text` |
| 400 | `bad_type` | an unknown `type` on `/search` |
| 429 | `rate_limited` | over a limit above |
| 503 | `unavailable` | the name index or the game text could not be loaded on the server |
```bash
curl "https://fivemad.com/api/redm/hash?q=1&kind=nope"
```
```json
{
"error": "bad_kind",
"message": "Unknown kind \"nope\". Known kinds: ped, weapon, ammo, vehicle, blip, blipStyle, control, promptHold, scenario, timecycle, weather, zone, interior, imap, script, item, document, label.",
"docs": "https://fivemad.com/redm/docs/ai/api"
}
```
A value that is neither a hash nor a usable name is not an error for the whole call: that one entry of `results` carries `"error": "invalid"` and the rest are answered.
## A worked example
"Spawn a white Arabian next to the player, and make sure the model name is real."
```bash
# 1. is the name real, and what is its hash?
curl "https://fivemad.com/api/redm/hash?q=a_c_horse_arabian_white"
```
```json
{
"results": [
{
"query": "a_c_horse_arabian_white",
"readAs": "name",
"name": "a_c_horse_arabian_white",
"lua": "`a_c_horse_arabian_white`",
"hash": { "unsigned": 3369743360, "signed": -925223936, "hex": "0xC8DA3400" },
"matchCount": 1,
"matches": [
{
"name": "a_c_horse_arabian_white",
"kind": "ped",
"kindLabel": "Ped model",
"page": "https://fivemad.com/redm/assets?t=peds&q=a_c_horse_arabian_white"
}
]
}
]
}
```
It is a ped model (on RDR2 a horse is a ped), so the spawn is a `CreatePed` plus the outfit call every RDR2 ped needs:
```lua title="client.lua"
local model = `a_c_horse_arabian_white` -- 0xC8DA3400
RequestModel(model)
while not HasModelLoaded(model) do Wait(0) end
local c = GetEntityCoords(PlayerPedId())
local ped = CreatePed(model, c.x + 2.0, c.y, c.z, 0.0, true, false, false, false)
-- _SET_RANDOM_OUTFIT_VARIATION: a RedM ped with no outfit is invisible
Citizen.InvokeNative(0x283978A15512B2FE, ped, true)
SetModelAsNoLongerNeeded(model)
```
Why the outfit line is there is explained in [Porting a FiveM resource](/redm/docs/porting). The same steps are what an assistant does when you ask it the question, which is covered on the [assistant page](/redm/docs/ai).
_Last updated: 2026-10-01_
---
# Getting started
## What RedM is
URL: https://fivemad.com/redm/docs/getting-started
RedM is the Cfx.re multiplayer platform for Red Dead Redemption 2 on PC. What it shares with FiveM, what it does not, and where to start.
RedM is the Cfx.re platform for running your own **Red Dead Redemption 2** multiplayer servers on PC, the same way FiveM does it for GTA V. Players start the RedM client on their own copy of RDR2 and join a server from the Cfx.re server list. You run that server with FXServer, the same server program FiveM uses, and you fill it with resources: folders of Lua (or JavaScript, or C#) with a manifest.
If you already run a FiveM server, most of what you know carries over. The part that changes is everything that touches the game itself.
## What is the same as FiveM
That part is the Cfx.re platform, so it is shared between the two games:
- **FXServer and its artifacts.** You download the same server builds. What makes a server a RedM server is two lines in `server.cfg`, see [Server setup](/redm/docs/server-setup).
- **txAdmin.** It ships with FXServer and has an official RedM recipe.
- **The resource system.** `fxmanifest.lua`, `ensure`, `stream/` folders, dependencies and load order work the same.
- **Server side scripting.** Events, exports, state bags, convars, ACE permissions, `PerformHttpRequest` and database code behave the same, because none of it touches the game.
- **NUI.** HTML pages drawn over the game work the same way.
## What is different
- **The game key.** A resource has to say it runs on `rdr3`, and an `rdr3` manifest needs one extra line or it does not start at all. That is the next page, [The fxmanifest](/redm/docs/getting-started/fxmanifest).
- **The natives.** RDR2 has its own natives. They do not match GTA V by name or by hash, and many are called by hash.
- **The game data.** Ped, horse, weapon, vehicle and prop names, blips, controls and text all come from RDR2. No GTA V list applies.
[RedM for a FiveM script author](/redm/docs/getting-started/differences) goes through these one by one, and [Porting a FiveM resource](/redm/docs/porting) is the checklist for moving an existing script.
## Where to go next
| You want to | Read |
| --- | --- |
| Start a RedM server | [Server setup](/redm/docs/server-setup) |
| Write your first RedM resource | [The fxmanifest](/redm/docs/getting-started/fxmanifest) |
| Pick a framework | [Frameworks](/redm/docs/frameworks) |
| Move a FiveM script over | [Porting a FiveM resource](/redm/docs/porting) |
| Use the RedM tools | [Tool guides](/redm/docs/tools) |
_Last updated: 2026-10-01_
---
## The fxmanifest and rdr3_warning
URL: https://fivemad.com/redm/docs/getting-started/fxmanifest
A RedM resource declares game 'rdr3' and carries the rdr3_warning line word for word, or it does not start. A minimal manifest you can copy.
Every resource has an `fxmanifest.lua` in its root folder. On RedM it is the same file as on FiveM with two differences: the `game` line says `rdr3`, and there is one extra line, `rdr3_warning`, that has to be there exactly as written.
## A minimal RedM manifest
```lua title="fxmanifest.lua"
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
lua54 'yes'
client_script 'client.lua'
server_script 'server.lua'
```
Next to it, a `client.lua` and a `server.lua`, then `ensure your_resource` in `server.cfg`. That is a working resource.
Line by line:
| Line | What it does on RedM |
| --- | --- |
| `fx_version 'cerulean'` | RedM needs `adamant`, `bodacious` or `cerulean`. The old `__resource.lua` style manifest does not work here. |
| `game 'rdr3'` | Says the resource runs on RDR2. `common` means "any game, Cfx.re APIs only". |
| `rdr3_warning '...'` | Required whenever `rdr3` is one of the games. See below. |
| `lua54 'yes'` | Lua 5.4, the same as on FiveM. |
## The rdr3_warning line
This is the exact text, the same one the stock Cfx.re resources carry (it is copied from `mapmanager`'s manifest in citizenfx/cfx-server-data):
```txt
I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.
```
It is an acknowledgement, not a comment. If the line is missing, or the text differs by a single character, the server refuses to start the resource. The usual ways to break it:
- retyping it instead of pasting it, and losing the `*` around *will*;
- an editor turning the straight quote in `I acknowledge` into a curly one;
- wrapping it onto two lines.
> [!TIP]
> The [fxmanifest Generator](/tools/fxmanifest-generator?game=rdr3) opens on `game 'rdr3'` with this line already filled in, and the [RedM Files](/redm/docs/tools/files) page checks a manifest you drop on it for both lines.
## Running on both games
A resource that has no game specific code (a chat command, a database helper, an NUI page that does not call natives) can run on both:
```lua title="fxmanifest.lua"
fx_version 'cerulean'
games { 'gta5', 'rdr3' }
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
```
The warning line is still required, because the resource does start on `rdr3`. A resource with only `game 'gta5'` does not start on a RedM server at all.
## Everything else is the same
`fx_version`, `lua54`, `shared_script`, `files`, `ui_page`, `dependency`, `data_file` and `this_is_a_map` mean what they mean on FiveM. The FiveM guide to [your first resource](/docs/development/first-resource) covers them.
What a `data_file` line or a `stream/` folder can replace is a different list, because the files are RDR2's. The [Resource Conflict Checker](/redm/docs/tools/resource-conflicts) tells you when two of your resources stream the same RDR2 file.
_Last updated: 2026-10-01_
---
## RedM for a FiveM script author
URL: https://fivemad.com/redm/docs/getting-started/differences
What changes when you write for RedM instead of FiveM: natives by hash, controls as hashes, peds that need an outfit, prompts, blips by style, and RDR2 game data.
You know FiveM Lua. Here is what feels different the first day on RedM. Each point has a longer version, with code, in [Porting a FiveM resource](/redm/docs/porting).
## Natives are called by hash
GTA V and RDR2 natives are two different sets. A GTA V native name does not exist on RDR2, and where both games have "the same" native, the hash is different. Many RDR2 natives have no settled name yet, so RedM scripts call them by hash:
```lua title="client.lua"
-- SET_BLIP_SCALE
Citizen.InvokeNative(0xD38744167B2FA257, blip, 0.2)
```
The hash never changes when a name does, which is why most RedM code you read looks like this. Write the native's name in a comment beside it, as above, or nobody can read the script a month later.
## Controls are hashes too
On GTA V a control is a small index (`38` for the pickup key). On RDR2 a control is the joaat hash of its `INPUT_` name, for example `INPUT_JUMP` is `0xD9D0E1C0`. The [Hash Calculator](/redm/docs/tools/hash-calculator) gives you any of them, and the [RedM Assets](/redm/docs/tools/assets) page lists every input action the game defines.
```lua title="client.lua"
if IsControlJustPressed(0, 0xD9D0E1C0) then -- INPUT_JUMP
end
```
## A ped needs an outfit
An RDR2 ped model spawned with nothing else done to it is invisible. Give it an outfit right after `CreatePed`:
```lua title="client.lua"
local ped = CreatePed(model, x, y, z, heading, true, false, false, false)
-- _SET_RANDOM_OUTFIT_VARIATION: a RedM ped with no outfit is invisible
Citizen.InvokeNative(0x283978A15512B2FE, ped, true)
```
`CreatePed` itself takes different arguments than on GTA V: there is no ped type first. Horses are peds too, spawned the same way.
## "Press E" is a prompt
The game's own way of offering an action is a **prompt**: the small key and label in the corner, with press, hold and mash variants and the hold timings the game itself uses. A FiveM style help text box and a hard coded key check is the thing that makes a port feel out of place. The [Prompt Builder](/redm/docs/tools/prompt-builder) writes the prompt code for you.
## Blips start from a style
A GTA V blip is a sprite id plus a colour id. An RDR2 blip is created from a **blip style** (a hash), and the style decides the icon, colour and label; you can then swap the icon for another sprite, also by hash:
```lua title="client.lua"
-- BLIP_ADD_FOR_COORDS: the style decides the icon, colour and label
local blip = Citizen.InvokeNative(0x554D9D53F696D002, joaat("BLIP_STYLE_PICKUP_WEAPON"), x, y, z)
-- SET_BLIP_SPRITE: another icon than the style's own
Citizen.InvokeNative(0x74F74D3207ED525C, blip, joaat("blip_shop_store"), true)
```
That pair (a style for the behaviour, a sprite for the icon) is how rsg-shops creates its store blips.
[Blip Styles](/redm/docs/tools/blip-styles) lists every style and [Blip Placer](/redm/docs/tools/blip-placer) writes this code for a set of points.
## The game data is all new
Model names, weapons, scenarios, timecycles, zones, interiors and text labels are RDR2's. None of the GTA V lists apply, and a GTA V model name copied into a RedM script never loads. Look names up on [RedM Assets](/redm/docs/tools/assets) or in the [Game Text Search](/redm/docs/tools/text-search).
## What you do not have to relearn
Server scripts, events, exports, state bags, NUI, convars, ACE and your database layer work exactly as on FiveM. The FiveM guides on [client and server events](/docs/development/client-server-events), [exports](/docs/development/exports-dependencies), [NUI](/docs/development/nui) and [state bags](/docs/development/state-bags-onesync) apply as written, as long as the example does not call a GTA V native.
_Last updated: 2026-10-01_
---
# Server setup
## Set up a RedM server
URL: https://fivemad.com/redm/docs/server-setup
A RedM server is FXServer with set gamename rdr3 and the enforced RDR2 build. The artifacts, the server.cfg lines, the stock resources and txAdmin.
A RedM server is the same FXServer you would run for FiveM. You download the same artifacts, install it the same way, and start it the same way. What makes it a RedM server is two lines in `server.cfg`: the game name and the RDR2 build.
## The two lines
```cfg title="server.cfg"
set gamename rdr3
sv_enforceGameBuild 1491
```
| Line | What it does |
| --- | --- |
| `set gamename rdr3` | Runs the server for RDR2. Without it the server runs for GTA V, as a FiveM server. |
| `sv_enforceGameBuild 1491` | The RDR2 game build players run on. 1491 is the September 2022 update, and it is the one RedM build docs.fivem.net lists for this convar. The generator writes it as `set sv_enforceGameBuild 1491`, which sets the same convar. |
## The full block from the official recipe
These are the lines of citizenfx's [default-redm txAdmin recipe](https://github.com/citizenfx/txAdmin-recipes/tree/main/default-redm) that make it a RedM server, with the stock resources it starts:
```cfg title="server.cfg"
# the lines that make it a RedM server (from the official default-redm recipe)
set gamename rdr3
sv_enforceGameBuild 1491
# the stock resources that recipe starts
ensure mapmanager
ensure chat
ensure spawnmanager
ensure redm-map-one
ensure hardcap
```
`redm-map-one` takes the place of the FiveM map resource. The rest of a `server.cfg` (endpoints, `sv_licenseKey`, `sv_maxclients`, `sv_hostname`, ACE lines, convars) is written exactly as for FiveM; the FiveM page [server.cfg explained line by line](/docs/server-setup/server-cfg) covers every one of them.
> [!TIP]
> The [server.cfg Generator](/redm/tools/server-cfg-generator) writes a complete RedM `server.cfg` with these lines, the stock resources, and presets taken from the VORP and RSG txAdmin recipes. Its guide is [here](/redm/docs/tools/server-cfg-generator).
## Artifacts
RedM uses the same FXServer builds as FiveM. Pick a recommended one, and avoid the builds marked broken, on the [Server artifacts](/artifacts) page. Installing them is covered for [Windows](/docs/server-setup/windows) and [Linux](/docs/server-setup/linux) in the FiveM docs, and nothing in those steps changes for RedM.
## License key
The `sv_licenseKey` comes from [portal.cfx.re](https://portal.cfx.re), the same portal and the same kind of key as for FiveM.
## txAdmin
txAdmin ships with FXServer. When it asks for a recipe, pick a RedM one:
| Recipe | What you get |
| --- | --- |
| citizenfx default-redm | The stock resources above and nothing else. Good for a standalone server or to learn on. |
| VORP | The VORP framework with its resources and database. txAdmin's own recipe list carries it. |
| RSG | The RSG framework, from Rexshack-RedM's own recipe. |
[Frameworks](/redm/docs/frameworks) explains how VORP and RSG differ.
## Before you start it
- Every resource you add needs `game 'rdr3'` and the `rdr3_warning` line in its manifest, or it does not start. See [The fxmanifest](/redm/docs/getting-started/fxmanifest).
- A FiveM resource does not start on a RedM server as it is. See [Porting a FiveM resource](/redm/docs/porting).
- Pool sizes (`increase_pool_size`) are a different set on RedM, with their own limits. The generator lists the RedM ones; raise a pool only when the console says it is full.
## Checking it is up
The [Server Status Checker](/tools/server-status-checker) and the [Uptime Badge](/tools/server-uptime-badge) read RedM servers from the same Cfx.re list as FiveM ones, so they work for your RedM server unchanged.
_Last updated: 2026-10-01_
---
# Frameworks
## VORP, RSG or standalone
URL: https://fivemad.com/redm/docs/frameworks
The RedM frameworks that are maintained today, VORP and RSG, how their data is laid out, their licenses, and when to go standalone instead.
A framework is the set of resources that gives a roleplay server its players, characters, money, inventory and jobs. On RedM two are maintained: **VORP** and **RSG**. You can also run without one.
| Framework | License | Repository | Docs |
| --- | --- | --- | --- |
| VORP | GPL-2.0 | [VORPCORE/vorp_core](https://github.com/VORPCORE/vorp_core) | [docs.vorp-core.com](https://docs.vorp-core.com) |
| RSG | GPL-3.0 | [Rexshack-RedM/rsg-core](https://github.com/Rexshack-RedM/rsg-core) | [rsgcore.com/docs](https://rsgcore.com/docs) |
| RedEM:RP | GPL-3.0 (modules) | [RedEM-RP](https://github.com/RedEM-RP) | none |
The licenses are read from each repository's own LICENSE file. Both VORP and RSG are GPL: check what that means for you before you sell a script built on them.
## VORP
VORP has its own layout. A player is a row in `users` and each of their characters a row in `characters`; items live in `items` and `character_inventories`, and weapons in a separate `loadout` table.
The official txAdmin recipe list carries a VORP recipe (VORPCORE/VORP_txAdmin), so you can get a working VORP server from txAdmin's setup screen without installing anything by hand.
## RSG
RSG is a fork of QBCore. A player is a `players` row with a `citizenid` and JSON columns, and items and jobs are defined in shared Lua files.
If your team already knows QBCore from FiveM, RSG is the natural pick: the structure, the naming and the way resources talk to the core will be familiar. Rexshack-RedM publishes a txAdmin recipe for it.
## Standalone
Standalone means no framework: the stock resources from the [default-redm recipe](/redm/docs/server-setup) plus whatever you write or install. That is the right choice for:
- a freeroam, race or event server that has no characters, money or inventory;
- learning RedM scripting without a framework's conventions in the way;
- a resource you want to sell to everybody, which then works on any server and leaves the framework glue to the buyer.
If a standalone resource later needs a framework, keep the framework calls in one small file per framework so the rest of the code does not change.
## RedEM:RP
RedEM:RP has had no commits since 2024. It is fine to read for ideas, but risky to start a new server on.
## What changes between them in practice
Items are the place you notice it first. The [Item Generator](/redm/docs/tools/item-generator) takes RDR2 items with their game icons and writes them either as VORP items SQL or as an RSG shared items Lua block, and the [Blip Placer](/redm/docs/tools/blip-placer) and [Door Finder](/redm/docs/tools/door-finder) write config blocks in the shape each framework's resources expect. The [server.cfg Generator](/redm/docs/tools/server-cfg-generator) has a preset for each.
_Last updated: 2026-10-01_
---
# Porting from FiveM
## Porting a FiveM resource to RedM
URL: https://fivemad.com/redm/docs/porting
What changes when a FiveM resource moves to RedM, in the order you hit it: the game key, natives by hash, controls, peds and outfits, prompts, blips and game data.
The platform is shared, the game is not. Server code usually moves over untouched; client code that calls natives is rewritten. This is the order people run into the changes.
## 1. The game key
A resource declares the games it runs on, and one with only `game 'gta5'` does not start on an `rdr3` server. Change the manifest:
```lua title="fxmanifest.lua"
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
```
Use `games { 'gta5', 'rdr3' }` instead if the same code is meant to run on both. The `rdr3_warning` line has to be word for word, see [The fxmanifest](/redm/docs/getting-started/fxmanifest).
## 2. Natives: a different set, often called by hash
GTA V and RDR2 natives do not match by name or by hash. A GTA V native that RDR2 does not have fails the first time that line runs. Many RDR2 natives have no settled name yet, so RedM scripts call them as `Citizen.InvokeNative` with the hash, and write the name in a comment:
```lua title="client.lua"
-- SET_BLIP_SCALE (0xD38744167B2FA257)
Citizen.InvokeNative(0xD38744167B2FA257, blip, 0.2)
```
When a native returns something, tell `InvokeNative` what to read back, the same way the [Prompt Builder](/redm/docs/tools/prompt-builder) output does it:
```lua title="client.lua"
local N = Citizen.InvokeNative
local p = N(0x04F97DE45A519419, Citizen.ResultAsInteger()) -- _UI_PROMPT_REGISTER_BEGIN
```
Go through the client files native by native. Some common ones keep their name on RedM (`PlayerPedId`, `GetEntityCoords`, `RequestModel`, `IsControlJustPressed`, all used in the code our RedM tools write); everything else needs its RDR2 equivalent looked up, not guessed.
## 3. Controls are hashes
On GTA V `IsControlJustPressed(0, 38)` is the pickup key. On RDR2 a control is the joaat hash of its `INPUT_` name:
| Control | Hash |
| --- | --- |
| `INPUT_JUMP` | `0xD9D0E1C0` |
| `INPUT_ENTER` | `0xCEFD9220` |
```lua title="client.lua"
if IsControlJustPressed(0, 0xCEFD9220) then -- INPUT_ENTER
end
```
Every input action of the game is listed on [RedM Assets](/redm/docs/tools/assets) under Controls, and the [Hash Calculator](/redm/docs/tools/hash-calculator) turns any `INPUT_` name into its hash.
## 4. Peds need an outfit
A ped spawned from a model with nothing else done to it is invisible on RDR2. Every ped spawn in a port needs an outfit call after it:
```lua title="client.lua"
local model = joaat("a_c_horse_arabian_white")
RequestModel(model)
while not HasModelLoaded(model) do Wait(0) end
local ped = CreatePed(model, x, y, z, heading, true, false, false, false)
-- _SET_RANDOM_OUTFIT_VARIATION: a RedM ped with no outfit is invisible
Citizen.InvokeNative(0x283978A15512B2FE, ped, true)
SetModelAsNoLongerNeeded(model)
```
`CreatePed` has no ped type argument first, unlike GTA V. A horse is a ped model, so this is also how a horse is spawned.
## 5. "Press E" becomes a prompt
FiveM scripts usually show a help text box ("Press ~INPUT_CONTEXT~ to open") and check a key every frame. RDR2's own way is a **prompt**: the key and label in the corner of the screen, with press, release, hold and mash modes and the game's own hold timings, grouped under a title.
A prompt is created once, shown with `_UI_PROMPT_SET_ACTIVE_GROUP_THIS_FRAME` every frame while the player is near, and checked with the `_UI_PROMPT_HAS_..._COMPLETED` natives. Every one of those is a call by hash, so there is no reason to write it by hand: the [Prompt Builder](/redm/docs/tools/prompt-builder) writes the whole resource for you, with a zone check around a point.
## 6. Blips are created from a style
A GTA V blip is a sprite number and a colour number. An RDR2 blip is created from a **blip style**, a hash that decides the icon, colour and label, and the icon can then be swapped for a sprite, also by hash:
```lua title="client.lua"
-- BLIP_ADD_FOR_COORDS (0x554D9D53F696D002): the style decides the icon, colour and label
local blip = Citizen.InvokeNative(0x554D9D53F696D002, joaat("BLIP_STYLE_PICKUP_WEAPON"), x, y, z)
-- SET_BLIP_SPRITE (0x74F74D3207ED525C): another icon than the style's own
Citizen.InvokeNative(0x74F74D3207ED525C, blip, joaat("blip_shop_store"), true)
-- _SET_BLIP_NAME (0x9CB1A1623062F402)
Citizen.InvokeNative(0x9CB1A1623062F402, blip, "General Store")
```
The GTA V sprite and colour numbers mean nothing here. Pick styles on [Blip Styles](/redm/docs/tools/blip-styles) and place blips with the [Blip Placer](/redm/docs/tools/blip-placer), which writes this code for a whole list of points.
## 7. Game data is new
Ped, horse, weapon, vehicle and prop names, scenarios, timecycles, weathers, zones, interiors and text labels all come from RDR2. None of the GTA V lists apply. Replace every model name, weapon name, coordinate and text label in the port:
- names and hashes: [RedM Assets](/redm/docs/tools/assets)
- coordinates: [Coords Picker](/redm/docs/tools/coords-picker)
- text labels: [Game Text Search](/redm/docs/tools/text-search)
- doors for a door lock script: [Door Finder](/redm/docs/tools/door-finder)
## What carries over unchanged
Server side code, NUI pages, events, state bags, convars, exports, ACE and database code work the same, because that part is the Cfx.re platform, not the game. A server file that only handles events and talks to the database often needs no change at all.
## A porting checklist
1. Manifest: `game 'rdr3'` (or `games`), the warning line, `fx_version` `cerulean`.
2. Every client native: find its RDR2 equivalent, call it by hash where it has no name, comment the name.
3. Every control number: replace with the `INPUT_` hash.
4. Every `CreatePed`: new argument list, plus an outfit call.
5. Every help text interaction: a prompt.
6. Every blip: a style hash and a sprite hash.
7. Every model, weapon, coordinate and label: an RDR2 one.
8. Drop the resource on the [Resource Conflict Checker](/redm/docs/tools/resource-conflicts) with the rest of your server to catch manifest mistakes before you restart.
_Last updated: 2026-10-01_
---
# Tools
## RedM tool guides
URL: https://fivemad.com/redm/docs/tools
One guide per fivemad RedM tool, plus the RedM Files and RedM Assets pages: what each is for, its options, and what to do with what it gives you.
Every RedM tool on fivemad runs in your browser and is free. The guides below explain the options and the output of each one. They are grouped the same way as the [RedM tools page](/redm/tools).
| Group | What is in it |
| --- | --- |
| Generators | Config and code you paste into a resource: [server.cfg](/redm/docs/tools/server-cfg-generator), [prompts](/redm/docs/tools/prompt-builder), a [loading screen](/redm/docs/tools/loading-screen), [items](/redm/docs/tools/item-generator), plus the [Photo Mode Converter](/redm/docs/tools/photo-converter) and the [Resource Conflict Checker](/redm/docs/tools/resource-conflicts). |
| Reference | Look things up: the [Hash Calculator](/redm/docs/tools/hash-calculator) and the [Game Text Search](/redm/docs/tools/text-search). |
| On the map | The RDR2 map and the tools drawn on it: the [Interactive Map](/redm/docs/tools/map), [Coords Picker](/redm/docs/tools/coords-picker), [Blip Placer](/redm/docs/tools/blip-placer), [Blip Styles](/redm/docs/tools/blip-styles), [Door Finder](/redm/docs/tools/door-finder), [Imap Toggler](/redm/docs/tools/imap-toggler), [Train Tracks](/redm/docs/tools/train-tracks) and [Interiors](/redm/docs/tools/interiors). |
| Textures and the map | Build files the game streams: [Folders to YTD](/redm/docs/tools/folders-to-ytd), the [Blip Replacer](/redm/docs/tools/blip-replacer) and the [Map Editor](/redm/docs/tools/map-editor). |
| Game assets | [RedM Files](/redm/docs/tools/files), a workspace that reads RDR2 and RedM files you drop on it, and [RedM Assets](/redm/docs/tools/assets), the game data with hashes. |
Some fivemad FiveM tools work for RedM unchanged, because they do not depend on the game: the [fxmanifest Generator](/tools/fxmanifest-generator?game=rdr3) (opens on `game 'rdr3'` with the warning line), the [Server Status Checker](/tools/server-status-checker), the [Uptime Badge](/tools/server-uptime-badge), the [Cfx.re Blacklist Checker](/tools/cfx-blacklist-checker) and the [Script Thumbnail Creator](/tools/script-thumbnail-creator). Their guides are in the [FiveM docs](/docs/tools).
_Last updated: 2026-10-01_
---
## server.cfg Generator
URL: https://fivemad.com/redm/docs/tools/server-cfg-generator
Fill in a form and get a RedM server.cfg with set gamename rdr3, the enforced build and the resource lists of the default, VORP and RSG recipes.
The server.cfg Generator writes a complete `server.cfg` for a RedM server from a form. Pick a framework preset, fill in your name, key and admins, and copy or download the file. The preview on the right updates on every change.
## What it is for
A RedM server.cfg is a FiveM server.cfg with a few lines that matter a lot: `set gamename rdr3`, the RedM build to enforce, and RedM's own stock resources (`redm-map-one` instead of the GTA ones). Getting one of those wrong gives you a server that starts GTA V resources or none at all. This tool starts from the lines the official recipes use and lets you change the rest.
## Quick start
1. Pick a **Framework**: **Standalone**, **VORP** or **RSG**. This replaces the resource list and sets the tags.
2. Fill in **Server identity** (hostname, project name, description, tags).
3. Paste your key into **sv_licenseKey** under **Keys and branding**.
4. Add yourself under **Permissions (ACE)**, **Admins**: pick the identifier type and paste the value.
5. Copy the `server.cfg` on the right, or press **Download**.
6. Put it in your server-data folder next to `resources` and start the server (or point txAdmin at it).
Clear the two amber warnings at the top of the preview before you go live. With the defaults they read "Set sv_licenseKey" and "No admin identifier set".
## The default file
This is what the form writes before you change anything (Standalone preset, txAdmin on):
```cfg title="server.cfg"
# ==========================================================
# server.cfg (RedM)
# Generated with fivemad.com/redm/tools/server-cfg-generator
# Docs: https://docs.fivem.net/docs/server-manual/setting-up-a-server/
# ==========================================================
#
# txAdmin: start the server from txAdmin, not with +exec.
# txAdmin reads the port from the endpoint lines below, so keep them.
# Restarts, schedules and bans are handled in the txAdmin panel.
## Networking
endpoint_add_tcp "0.0.0.0:30120"
endpoint_add_udp "0.0.0.0:30120"
## Server identity
sv_hostname "^5My RedM Server ^7| Western RP"
sets sv_projectName "My RedM Server"
sets sv_projectDesc "Western roleplay on RedM"
sets locale "en-US"
sets tags "default"
## Slots and game
set gamename rdr3
sv_maxclients 48
set onesync on
set sv_enforceGameBuild 1491 # September 2022 update
## Security
sv_endpointprivacy true
## Keys
set steam_webApiKey "none" # https://steamcommunity.com/dev/apikey
sv_licenseKey "changeme" # https://portal.cfx.re
## Standalone settings (from its txAdmin recipe)
set resources_useSystemChat true
## Resources (load order matters)
# Default cfx resources (default-redm recipe)
ensure mapmanager
ensure chat
ensure spawnmanager
ensure redm-map-one
ensure hardcap
## Permissions
add_ace group.admin command allow # all commands
add_ace group.admin command.quit deny # but not quit
# add_principal identifier.license:xxxxxxxx group.admin # add yourself here
```
`set gamename rdr3` is always written. It is what makes the server a RedM one.
## Framework presets
Each preset is copied from that framework's own txAdmin recipe: its resource order, the convars it sets and the ACE lines it adds.
| Preset | Resource list | Extra lines | Admin group |
| --- | --- | --- | --- |
| **Standalone** | The five stock resources of the official default-redm recipe | `set resources_useSystemChat true` | `group.admin` |
| **VORP** | Stock resources, `pma-voice`, `loadingscreen`, the dependencies, two `exec` lines for permission files, then the `vorp_` resources in the recipe's order | Five convars (slow query warning, txAdmin menu particle effects off, system chat, join and quit messages off) and two `add_ace resource.vorp_lib` lines | `group.admin` |
| **RSG** | `mapmanager`, `spawnmanager`, `oxmysql`, `ox_lib`, the RSG core resources, then the `[standalone]`, `[framework]`, `[mapmods]` and `[community]` folders | `rsg_locale`, `ox:` colours, `UseTarget` and others from the recipe, plus the `rsgcore.god` to `rsgcore.helper` permission chain | `rsgcore.god` |
Picking **VORP** or **RSG** also turns on **Database** and **Voice (pma-voice)**, because both frameworks need them. **RSG** additionally switches voice to 3D audio, turns the built in UI on and **Sending range only** off, which is what its recipe sets. An admin row that still has a preset's admin group is moved to the new preset's group.
> [!NOTE]
> Folder names such as `[standalone]` and `[framework]` are the folders those recipes download into. If you install the framework by hand, use the same folders or edit the list.
## Panels and options
### Server identity
| Option | What it does | Default |
| --- | --- | --- |
| **sv_hostname** | Name in the server list. `^1` to `^9` are colour codes. | see the file above |
| **Project name** | `sets sv_projectName`. | `My RedM Server` |
| **Locale** | `sets locale`, one of 25 codes. | `en-US` |
| **Project description** | `sets sv_projectDesc`. | `Western roleplay on RedM` |
| **Tags** | Comma separated, written as `sets tags`. | `default` |
### Slots, network and game
| Option | What it does | Default |
| --- | --- | --- |
| **sv_maxclients** | Slider and number box, 1 to 2048. | 48 |
| **OneSync** | `on`, `legacy` or `off`. | `on` |
| **Bind IP** | Address in the two `endpoint_add` lines. `0.0.0.0` listens on every interface. | `0.0.0.0` |
| **Port** | TCP and UDP port. Both must be open. | 30120 |
| **sv_enforceGameBuild** | **Default (not enforced)** or **1491: September 2022 update**, the one RedM build the Cfx.re docs list. | 1491 |
### Keys and branding
**sv_licenseKey** (from portal.cfx.re), **steam_webApiKey** (written as `none` when empty), **Server icon file** (a 96x96 PNG next to server.cfg, written as `load_server_icon`), **Discord**, **banner_detail URL**, **banner_connecting URL**, **sv_tebexSecret**, and **Extra sets variables** for any other `sets key "value"` line you want. Empty fields are left out of the file.
### Security
| Option | What it does | Default |
| --- | --- | --- |
| **Running under txAdmin** | Adds the txAdmin notes at the top and leaves rcon out. Off shows an **rcon_password** field. | on |
| **sv_endpointprivacy** | Hides player IPs from other players. | on |
| **Private server** | Writes `sv_master1 ""` so the server is not listed. | off |
| **sv_pureLevel** | Not set, `1` or `2`. | Not set |
| **sv_entityLockdown** | Not set, `relaxed` or `strict`. | Not set |
### Database
Off by default. **Enabled** writes one `set mysql_connection_string` line for oxmysql from **Host**, **Port**, **User**, **Password** and **Database** (default database name `redm`). The password is URL encoded for you, so special characters are safe.
### Voice (pma-voice)
Off by default. **Enabled** writes the pma-voice convars: **Audio mode** (native 3D, 2D by distance, 3D audio, or the pma-voice default), **Sending range only**, **Built-in UI**, **Radio animation**, **Range key** (`F11`) and **Radio key** (`LMENU`). If `pma-voice` is not already in your resource list (or in a folder the preset says holds it), an `ensure pma-voice` line is added at the end of the resources.
### Pool sizes
Empty by default. **Add pool** adds an `increase_pool_size` row. The pool list and the maximum next to each one are the RedM column of the table on docs.fivem.net, and a number over the maximum is capped, because the server ignores a value past it.
| Pool | Max | Pool | Max |
| --- | --- | --- | --- |
| AttachmentExtension | 430 | OcclusionInteriorInfo | 10 |
| CAvoidanceComponent | 1300 | OcclusionPathNode | 1500 |
| CDoorExtension | 160 | OcclusionPortalEntity | 140 |
| CLightEntity | 2000 | OcclusionPortalInfo | 140 |
| CMoveObject | 100 | PortalInst | 150 |
| CompEntity | 50 | ScaleformStore | 100 |
| CPropSetObjectExtension | 950 | StaticBounds | 6500 |
| DrawableStore | 50000 | TxdStore | 26000 |
| FragmentStore | 4000 | CNetObjDoor | 20 |
| GrassBatch | 2000 | CDoorSyncData | 20 |
| InteriorProxy | 450 | | |
| netGameEvent | 400 | | |
| Object | 2000 | | |
Raise a pool only when the server console tells you it is full.
### Resources
One entry per line, in load order:
- A plain name becomes `ensure name`.
- `[folder]` becomes `ensure [folder]`, which starts every resource in that folder.
- A line starting with `#` stays a comment.
- A line that already starts with `ensure`, `start`, `stop`, `restart`, `exec`, `set`, `setr` or `sets` is written as it is.
If the list contains `ox_lib` (or `[ox]`), the file also gets `setr ox:locale "en"` and the four ox_lib ACE lines it needs.
### Permissions (ACE)
**Admins** takes an identifier type (`license`, `license2`, `fivem`, `discord`, `steam`, `xbl`, `live`, `ip`), the value, a group and a note. Paste just the value: a leading `license:` (or whichever type you picked) is stripped, so it is never written twice. **Custom rules** adds your own `add_ace` and `add_principal` lines; **Hide custom rules** folds that part away.
## Tips
- The form is saved in your browser, separately from the FiveM server.cfg generator, so you can come back to it. **Reset** puts every field back to the defaults above.
- Change the framework first and the rest after: picking a preset replaces the resource list and the tags.
- Find a player's identifiers in txAdmin (Players, then a player), or print `GetPlayerIdentifiers(source)` from a server script.
## Common mistakes
- **A resource does not start.** Every resource on a RedM server needs `game 'rdr3'` and the `rdr3_warning` line in its `fxmanifest.lua`. Use the [Resource Conflict Checker](/redm/docs/tools/resource-conflicts) to find the ones that are missing it.
- **Framework errors about the database.** VORP and RSG need MariaDB or MySQL. The preset turns **Database** on, but the default password is empty, which the warning panel points out.
- **`ensure [standalone]` starts nothing.** The folder name has to match the folder on disk exactly, brackets included.
- **Two loading screens.** The VORP preset starts `loadingscreen`. If you build your own with the [Loading Screen Generator](/redm/docs/tools/loading-screen), take that line out.
## Limitations
- Only one RedM game build is offered, because docs.fivem.net lists only one.
- The presets follow the recipes as they were when the tool was written. If a framework renames or adds resources later, edit the list by hand.
- It writes the config only. It does not install resources, create the database or check that the resources in the list exist.
## Related tools
- [Resource Conflict Checker](/redm/docs/tools/resource-conflicts)
- [Loading Screen Generator](/redm/docs/tools/loading-screen)
- [Item Generator](/redm/docs/tools/item-generator)
_Last updated: 2026-10-01_
---
## Prompt Builder
URL: https://fivemad.com/redm/docs/tools/prompt-builder
Build a group of RDR2 prompts (press, hold or mash) on the game's own input actions and hold timings, try them in a preview, and download the Lua.
The Prompt Builder makes the "press E to ..." boxes RDR2 shows in the bottom right of the screen. You set up a group of prompts, try each one in a preview that behaves like the real thing, and get a ready resource: a `client.lua` that registers the prompts, shows the group near a spot and fires an event when a prompt completes, plus its `fxmanifest.lua`.
## What it is for
Prompts are the standard way to offer an action in RedM, but setting one up takes a dozen native calls, a control hash, a hold type hash and a text label trick, and nothing shows until every step is right. Here you pick the action and the timing from the game's own lists and get code that already works, so you only have to write what happens when the prompt fires.
## Quick start
1. In **Group**, set the **Group name** (the line under the prompts) and the **Resource name**.
2. Leave **Only near a spot** on and type the **X**, **Y**, **Z** and **Radius (m)** of the place, or turn it off while you test so the group shows everywhere.
3. Edit **Prompt 1** and **Prompt 2**, or press **Add prompt**. For each one set the **Text**, the **Input action** and the **Mode**.
4. Put the client event your script listens for in **Event to trigger**.
5. Click or hold the rows in the preview to check the timing.
6. Press **Download resource**, unzip into `resources` and add `ensure ` to `server.cfg`.
## Group
| Option | What it does | Default |
| --- | --- | --- |
| **Group name** | The text under the prompts. | `Valentine bank` |
| **Resource name** | Folder and zip name, and the `name` in the manifest. Anything that is not a letter, digit, `_` or `-` becomes `_`. | `my_prompts` |
| **Only near a spot** | Show the group only within the radius of a point. Off shows it everywhere. | on |
| **X**, **Y**, **Z** | The point. | `-308.42`, `775.88`, `118.7` (the Valentine bank) |
| **Radius (m)** | Distance from the point, measured in 3D. | 2 |
**Reset** puts the whole document back to these defaults.
## Prompts
| Option | What it does | Default for a new prompt |
| --- | --- | --- |
| **Text** | What the prompt says. | `New prompt` |
| **Id** | The prompt's name in the Lua table and in the console message. | `prompt` |
| **Input action** | The `INPUT_` action the prompt listens to. Type to search the game's 373 actions. The hint shows its hash and the controller button it reads. | `INPUT_CONTEXT_A` |
| **Mode** | How the player completes it (see below). | **Press** |
| **Tab** | 1 to 8. Prompts on tab 2 and up sit on another page of the group. | 1 |
| **Key in the preview** | The key drawn in the preview, up to 6 characters. In game RDR2 draws the player's own binding. | `G` |
| **Event to trigger** | A client event fired when the prompt completes. Empty prints `prompt completed` to the F8 console instead. | empty |
The cross on a prompt's panel removes it.
## Modes
| Mode | What the player does | Extra field |
| --- | --- | --- |
| **Press** | Presses the key. | none |
| **Press, fire on release** | Presses and lets go. It completes on release. | none |
| **Hold (game timing)** | Holds the key for one of the game's own hold timings. | **Hold timing** |
| **Hold (your own time)** | Holds the key for any number of milliseconds. | **Hold time (ms)** |
| **Mash** | Presses the key a set number of times. | **Presses needed** |
**Hold timing** lists the hold types of the game's own `prompts.meta`, shortest first:
| Hold timing | Length |
| --- | --- |
| `SHORT_TIMED_EVENT_MP` | 250 ms |
| `SHORT_TIMED_EVENT` | 300 ms |
| `MEDIUM_TIMED_EVENT` | 600 ms |
| `LONG_TIMED_EVENT` | 1,500 ms |
| `PLAYER_FOCUS_TIMING` | 2,000 ms |
| `PLAYER_REACTION_TIMING` | 3,000 ms |
| `RUSTLING_CALM_TIMING` | 5,000 ms |
| `KEYBOARD_DELETE` | 5,000,000 ms |
These are the timings the game's own prompts use. `KEYBOARD_DELETE` is in the list because the game defines it, but at over 83 minutes it is not a hold anybody finishes, and the preview never completes it.
## The preview
The preview is drawn in the style of the in-game prompt box: one row per prompt on the current tab, the group name underneath, and `<` and `>` to switch tabs when there is more than one. Click a **Press** row, release on a **fire on release** row, hold a **Hold** row until its ring fills, or click a **Mash** row until the counter reaches the number. A row flashes when it completes. The look is drawn by the page, not taken from the game, so fonts and sizes are close rather than exact.
## What it writes
With the default document, `client.lua` starts with your settings:
```lua title="client.lua"
-- Generated with fivemad.com/redm/tools/prompt-builder
-- Prompt natives are called by hash (Citizen.InvokeNative). Each hash is commented with its
-- name in the RDR3 native database, so the script keeps working when a name changes.
local GROUP_NAME = "Valentine bank"
local ZONE = vector3(-308.42, 775.88, 118.7)
local RADIUS = 2.0
local TABS = 1
local PROMPTS = {
{ id = "bank", control = 0xD51B784F, text = "Open the bank", page = 0, mode = "standard", release = false }, -- INPUT_CONTEXT_Y
{ id = "rob", control = 0xE3BF959B, text = "Rob the vault", page = 0, mode = "hold", holdType = 0x87A8DDB3 }, -- INPUT_CONTEXT_X, LONG_TIMED_EVENT
}
```
The rest of the file is the same for every document: it registers each prompt, and every frame you are inside the radius it shows the group and checks each prompt. The part you will want to read is the handler:
```lua title="client.lua"
local function onPrompt(def)
if def.event then
TriggerEvent(def.event)
else
print(('prompt %s completed'):format(def.id))
end
end
```
Outside the radius the loop sleeps 500 ms between checks. A completed prompt cannot fire again for 1 second, so one long hold does not trigger twice. When the resource stops, every prompt it made is deleted.
Every prompt native is called by its hash through `Citizen.InvokeNative`, with its current name in a comment beside it. Many RDR3 natives have no settled name yet and names have changed between versions of the native list; the hash does not change. Text is passed through `VAR_STRING` with the game's `LITERAL_STRING` label, which is how RDR2 shows a plain string in a prompt.
`fxmanifest.lua` is short:
```lua title="fxmanifest.lua"
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
name 'my_prompts'
description 'Prompt group made with fivemad.com/redm/tools/prompt-builder'
client_script 'client.lua'
```
Switch between the two with the **client.lua** and **fxmanifest.lua** chips above the code.
## Handling the event
**Event to trigger** is fired with `TriggerEvent`, so it is a **client** event in the player's own game. Listen for it in a client script, and send it on to the server yourself if the server has to act:
```lua title="client.lua"
AddEventHandler('myshop:open', function()
TriggerServerEvent('myshop:server:open')
end)
```
## Tips
- Grab coordinates with the [Coords Picker](/redm/docs/tools/coords-picker) and paste them into **X**, **Y** and **Z**. The distance check includes height, so use a Z close to where the player stands.
- Turn **Only near a spot** off while testing, then back on before you ship.
- The defaults use the context actions `INPUT_CONTEXT_Y`, `INPUT_CONTEXT_X` and `INPUT_CONTEXT_A`. Give each prompt in a group its own action so the player can tell which key does what.
- Put actions you rarely need on tab 2, so the first page stays short.
- The document is saved in your browser, so you can close the page and come back to it.
## Common mistakes
The warning panel under the preview catches these before you download:
- **An input action that is not in the list.** The field turns amber and the code writes `control = 0`. Pick a name from the suggestions.
- **Two prompts with the same id.** Each needs its own.
- **A prompt with no text.**
- **An empty tab.** If a prompt is on tab 3 and none is on tab 2, the group shows an empty page.
And one it cannot catch: **the prompt shows but nothing happens.** The event name in **Event to trigger** has to match your `AddEventHandler` exactly, and it is a client event (see above).
## Limitations
- The preview key is decoration. In game RDR2 draws whatever key or button the player has bound to the action.
- The generated loop only knows one zone. For the same group in several places, edit `ZONE` into a list of points.
- The page cannot run RDR2, so how the prompt looks in game is not something it can show you exactly.
## Related tools
- [Coords Picker](/redm/docs/tools/coords-picker)
- [Interactive Map](/redm/docs/tools/map)
- [Hash Calculator](/redm/docs/tools/hash-calculator)
- [Game Text Search](/redm/docs/tools/text-search)
_Last updated: 2026-10-01_
---
## Loading Screen Generator
URL: https://fivemad.com/redm/docs/tools/loading-screen
Make a RedM loading screen resource with your title, tips, background image or video and music, a real progress bar and log line, downloaded as a zip.
The Loading Screen Generator builds the page players see while they join your RedM server, and wraps it in a resource you can drop into `resources`. You set the text, the background and the music, watch it in a live preview, and download a zip. The files you pick never leave your browser: they are packed into the zip on your machine.
## What it is for
A loading screen is a small web page inside a resource, plus a few manifest lines that tell RedM to show it. Most people grab a template and spend an hour on the HTML. Here the page is written for you, the progress bar is wired to the real loading events instead of a timer, and the manifest is already right for RedM.
## Quick start
1. Under **Text**, set the **Title**, the **Subtitle** and the **Tips** (one per line).
2. Under **Background**, pick **Plain colour**, **Image** or **Video**. For an image or video press **Pick image** or **Pick video**.
3. Optional: turn on **Play music** and **Pick music**.
4. Check the preview on the right. The bar and the log line move on their own there.
5. Set the **Resource name** and press **Download resource**.
6. Unzip into `resources`, add `ensure ` to `server.cfg` and restart the server.
> [!WARNING]
> Only one loading screen can be active. Stop or remove any other resource with a `loadscreen` line, such as the `loadingscreen` resource the VORP recipe starts.
## Options
### Text
| Option | What it does | Default |
| --- | --- | --- |
| **Title** | Big heading, shown in capitals. | `My RedM Server` |
| **Subtitle** | Line under the title. Empty hides it. | `Western roleplay` |
| **Tips** | One per line. They rotate under the title, with a fade between them. | two example lines |
| **Seconds per tip** | How long each tip stays, 2 to 30. | 8 |
| **Layout** | **Bottom left** or **Bottom centre**. | Bottom left |
**Reset** in the **Text** panel puts every setting back to the defaults.
### Background
| Option | What it does | Default |
| --- | --- | --- |
| **Plain colour** / **Image** / **Video** | What sits behind the text. Switching type drops the file you picked. | Plain colour |
| **Pick image** | PNG, JPEG, WebP or GIF. Covers the screen. | |
| **Pick video** | WebM or MP4. Plays muted and loops. | |
| **Colour** | The page colour, and what shows while a picture loads. | `#1b140e` |
| **Accent** | Colour of the progress bar fill. | `#c8a26a` |
| **Darken** | A dark gradient over the background so the text stays readable, 0 to 90%. | 35% |
### Music
| Option | What it does | Default |
| --- | --- | --- |
| **Play music** | Ship an audio file in the resource and play it on a loop. | off |
| **Pick music** | MP3, OGG or WAV. | |
| **Volume** | 0 to 100%. | 40% |
| **Mute button** | A **Mute** / **Unmute** button in the top right. | on |
### Loading and resource
| Option | What it does | Default |
| --- | --- | --- |
| **Progress bar** | A bar and a percentage, filled from the game's `loadProgress` event. | on |
| **Log line** | The latest `onLogLine` message under the bar. | on |
| **Show the cursor** | Adds `loadscreen_cursor 'yes'`. Needed for the mute button to be clickable. | on |
| **Close it on spawn** | Adds `loadscreen_manual_shutdown 'yes'` and a `client.lua` that closes the screen on `playerSpawned`. | on |
| **Resource name** | Folder and zip name. Anything that is not a letter, digit, `_` or `-` becomes `_`. | `my_loadscreen` |
Your settings are saved in your browser. The picked image, video and music files are not, so pick them again after a reload.
## What is in the zip
```
my_loadscreen/
fxmanifest.lua
client.lua (only with Close it on spawn)
html/
index.html
(if you picked one)
(if you picked one)
```
Media file names are cleaned up on the way in: anything that is not a letter, digit, `_` or `-` becomes `_`, and the name is cut to 40 characters before the extension. The chips above the code show **fxmanifest.lua**, **html/index.html** and **client.lua** as they will be written.
With the default settings the manifest is:
```lua title="fxmanifest.lua"
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
name 'my_loadscreen'
description 'Loading screen made with fivemad.com/redm/tools/loading-screen'
loadscreen 'html/index.html'
loadscreen_cursor 'yes'
loadscreen_manual_shutdown 'yes'
client_script 'client.lua'
files {
'html/index.html',
}
```
A picked background or music file is added to `files` as `html/`.
## Closing the screen
With **Close it on spawn** on, the resource keeps the screen up until the player has spawned, then closes it:
```lua title="client.lua"
-- Generated with fivemad.com/redm/tools/loading-screen
-- loadscreen_manual_shutdown is on, so this resource ends the loading screen itself once the
-- player has spawned (spawnmanager fires playerSpawned).
AddEventHandler('playerSpawned', function()
ShutdownLoadingScreen()
ShutdownLoadingScreenNui()
end)
```
`playerSpawned` comes from `spawnmanager`, which the default RedM recipe starts. If your framework spawns the player after a character select instead, change the event in `client.lua` to the one your framework fires at that point.
With it off, there is no `client.lua` and no manual shutdown line in the manifest, so the resource does not close the screen itself.
## The preview
The preview on the right is the real `index.html`, with your files loaded from your machine. Because nothing is loading in a browser, the preview adds a fake progress stream and a placeholder log line so you can see the bar move. That extra script is not in the downloaded file; in game RedM sends the real events.
## Size
Every file in the resource is downloaded by every player before the screen can show, so a big video means a long black screen first. The page warns you when the background is over 40 MB or the music is over 15 MB. A single image, or a short compressed WebM, is the safe choice.
## Tips
- Keep tips short. The tip line wraps at about 60 characters, so a long tip turns into a paragraph.
- Use **Darken** rather than editing your picture when the text is hard to read.
- Leave **Show the cursor** on if you keep the mute button, or players cannot click it.
## Common mistakes
- **The old loading screen still shows.** Another resource with a `loadscreen` line is running. Remove it from `server.cfg`.
- **The screen never closes.** **Close it on spawn** is on but nothing fires `playerSpawned` (for example `spawnmanager` is not started). Start it, or change the event in `client.lua`.
- **Only the plain colour shows.** You switched the background type after picking a file, or reloaded the page, and the file was dropped. The warning panel under the preview says "Pick a background image or switch to a plain colour" when that happens. Pick the file again before you download.
## Limitations
- The page starts the music itself and tries again on the first click if it was blocked. Whether a given client plays it before any click is up to RedM, not the page.
- The text styling is fixed: a serif font, the layout above, your colours. For anything else, edit `html/index.html` after you download.
- The page cannot run RDR2, so the in-game result is not something it can show you exactly.
## Related tools
- [server.cfg Generator](/redm/docs/tools/server-cfg-generator)
- [Resource Conflict Checker](/redm/docs/tools/resource-conflicts)
- [Photo Mode Converter](/redm/docs/tools/photo-converter)
_Last updated: 2026-10-01_
---
## Photo Mode Converter
URL: https://fivemad.com/redm/docs/tools/photo-converter
Turn RDR2 photo mode files (PRDR) into normal JPEG pictures in your browser, with where and when each photo was taken. Nothing is uploaded.
The Photo Mode Converter turns the photos RDR2 saves from photo mode into ordinary JPEG files you can open, share or use on a loading screen. It also shows what the game stored with each photo: the size, when it was taken, the in-game date and time, and where you stood. Everything runs in your browser; the files are never uploaded.
## Where the photos are
On PC, RDR2 keeps photo mode pictures in:
```
Documents\Rockstar Games\Red Dead Redemption 2\Profiles\
```
where `` is a folder named after your profile. Each photo is one file with a name like `PRDR31155361589_1` and **no extension**, which is why Windows does not open it as a picture.
## Quick start
1. Press **Pick the profile folder** and choose the `Profiles\` folder. Every file in it whose name starts with `PRDR` is converted.
2. Or press **Pick files** and choose some photos, or drag them onto the box.
3. Press **JPEG** under a photo to save that one, or **Download all** to get every converted photo in `rdr2-photos.zip`.
Each JPEG keeps the original name with `.jpg` added, so `PRDR31155361589_1` becomes `PRDR31155361589_1.jpg`.
## What you get
The picture inside a PRDR file already is a JPEG. The tool cuts it out byte for byte, so there is **no second compression and no quality loss**: the JPEG you download is the one the game saved.
Under each photo the card lists what the game stored, when it is there:
| Field | What it is |
| --- | --- |
| **Size** | The picture's width and height, and the JPEG's file size. |
| **Taken** | The real date and time the photo was saved. |
| **In game** | The in-game date and time in the photo. |
| **Position** | The x, y, z where the photo was taken. |
| **Mode** | **Story** for a single player photo, otherwise the value the game wrote. |
If a card says **Header did not check out, found by the JPEG markers**, the file's header did not match the usual layout and the picture was found by searching for the start and end of the JPEG instead. The result is still the game's own JPEG; it is just a sign the file is unusual.
**Clear** empties the list. Adding the same file twice is skipped.
## Errors you may see
| Message | Meaning |
| --- | --- |
| **Too small to be a photo mode file.** | The file is a few hundred bytes or less. It is some other profile file. |
| **Too large to be a photo mode file.** | Over 32 MB, which no photo is. |
| **No JPEG picture inside. Is this a PRDR photo file?** | The file holds no picture. |
| **The picture inside is cut off (no end marker).** | The file is damaged or was only partly copied. |
Files ending in `.jpg`, `.jpeg`, `.png`, `.webp`, `.txt` or `.json` are skipped when you pick or drop them, so a folder with earlier conversions next to the originals does not produce errors.
## Tips
- **Pick the profile folder** only takes files that start with `PRDR`, so the profile's save files are ignored. Use it rather than selecting files by hand.
- Use a converted photo as the background of a [Loading Screen Generator](/redm/docs/tools/loading-screen) resource.
## Limitations
- It reads PC photo mode files. It does not convert other RDR2 files, and it does not write PRDR files back.
- Dragging a whole folder onto the box does not read the files inside it. Use **Pick the profile folder** for a folder.
- The metadata fields only show when the game wrote them into the file.
## Related tools
- [Loading Screen Generator](/redm/docs/tools/loading-screen)
- [Interactive Map](/redm/docs/tools/map)
- [Coords Picker](/redm/docs/tools/coords-picker)
_Last updated: 2026-10-01_
---
## Resource Conflict Checker
URL: https://fivemad.com/redm/docs/tools/resource-conflicts
Drop several RedM resources at once and see duplicate stream files, replaced RDR2 files, repeated data_file lines and manifest mistakes.
The Resource Conflict Checker reads a pile of RedM resources and lists what will go wrong between them: two resources streaming the same file, a stream file that replaces one of RDR2's own, the same data file registered twice, and manifests that RedM will refuse to start. Drop your whole `resources` folder or add resources one by one. Nothing is uploaded.
## What it is for
Each resource can look fine on its own and still break the server next to another one. Two map mods that both stream the same file show whichever loads last; two copies of one script under different folder names fight over the same data. These problems give no clear error in the console. The checker looks at all the resources together and names the files involved.
It is also a quick way to catch the RedM manifest rules that stop a resource from starting at all, such as a missing `rdr3_warning` line.
## Quick start
1. Drag your `resources` folder (or several resource folders and zips) onto the box, or press **Add a folder** or **Add zips**.
2. Wait for **Checking** to finish.
3. Read the list on the left. Errors come first, then warnings, then notes. Each one names the files and, for a manifest, the line.
4. The panel on the right lists every resource found, its game and how many files it streams.
5. Add more resources at any time; the check reruns over everything. **Clear** starts over.
A resource is any folder with an `fxmanifest.lua` (or `__resource.lua`) in it, so bracket folders such as `[standalone]` are fine. A zip is kept apart under its own name, so two zips with the same layout inside do not mix.
## What it checks
### Errors
| Finding | What it means |
| --- | --- |
| `: no fxmanifest.lua` | Stream files or Lua files sit outside any resource, so the server never loads them. |
| `only has __resource.lua` | RedM needs an `fxmanifest.lua` with fx_version adamant or newer. |
| `no fx_version` | Add `fx_version 'cerulean'`. |
| `fx_version '...' is not adamant, bodacious or cerulean` | RedM needs one of those three. |
| `no game line` | Add `game 'rdr3'`, or `games { 'gta5', 'rdr3' }` for code that runs on both. |
| `made for gta5, not RedM` | The game line does not include `rdr3` or `common`, so it does not start on a RedM server. |
| `no rdr3_warning line` | A `game 'rdr3'` resource does not start without it. |
| `rdr3_warning text is not word for word` | The line has to match exactly, including the asterisks around *will*. |
| `N resources named ...` | Two folders with the same name. Resource names are unique on a server, so only one can start. |
| Manifest syntax | An unclosed string, block comment or table, a missing comma between entries, or a `data_file` line without a type and a path. |
The `rdr3_warning` line a RedM manifest needs is:
```lua title="fxmanifest.lua"
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
```
### Warnings
| Finding | What it means |
| --- | --- |
| `... is streamed by N resources` | Two or more resources stream a file with the same name. Streaming goes by file name, so only one copy is used. If every copy has the same size they are probably the same file: keep one. If the sizes differ, which one you see depends on the order the resources start in. |
| `N resources load ... as TYPE` | The same data file name is registered by two resources: usually two copies of one mod, or two mods editing the same game data. |
| `data_file '...' points at ..., which is not in the resource` | The path in the manifest matches no file. Globs are matched too. |
| `data_file '...' '...' is listed twice` | The same line twice in one manifest. |
| `has both fxmanifest.lua and __resource.lua` | Delete `__resource.lua` so there is no doubt which one is read. |
### Notes
| Finding | What it means |
| --- | --- |
| `... replaces N files of the game` | These stream file names also exist in RDR2 itself, so the streamed copy replaces the game's own. That is often the point (map edits, retextures), so it is a note, not a problem. |
| `... is in ... twice` | The same file name is streamed twice inside one resource, for example from two subfolders. |
## Which files count as stream files
A file counts when it sits in a `stream/` folder (at any depth inside the resource) and has one of these extensions: `.ydr`, `.ydd`, `.yft`, `.ytd`, `.ybn`, `.ymap`, `.ytyp`, `.ycd`, `.ynv`, `.ypt`, `.yld`, `.ymt`, `.awc`. File names are compared without regard to case.
The game file check knows **44,679** streamable file names of RDR2, across 12 types:
| Type | Names | Type | Names |
| --- | --- | --- | --- |
| `.ytd` | 18,232 | `.ytyp` | 273 |
| `.ycd` | 12,818 | `.ynv` | 128 |
| `.ymt` | 6,619 | `.ydd` | 120 |
| `.ydr` | 3,036 | `.yld` | 11 |
| `.yft` | 2,272 | `.ypt` | 6 |
| `.ymap` | 795 | | |
| `.ybn` | 369 | | |
Those are the game files that carry a readable name. Many more are stored in the game only under a hash of their path, so **a file that is not flagged can still be a game file**. `.awc` audio is counted as a stream file but not checked against the game.
If the game file list fails to load, the header says "The stock file list did not load, so game overrides are not checked." and every other check still runs.
## Tips
- Check the whole `resources` folder before a big update, then again after, and compare.
- Add a new download on its own next to your existing folder: every finding that names it is something it brings with it.
- System files (`__MACOSX`, `.git`, `node_modules`, `.DS_Store`, `Thumbs.db`, `desktop.ini`) are skipped.
## Common mistakes
- **The same resource added twice.** Dropping a folder and then its zip gives you "2 resources named ..." and a duplicate for every stream file. **Clear** and add it once.
- **Treating every note as a problem.** A map or texture mod is supposed to replace game files. The notes are there so you know which resource does it.
- **Fixing the rdr3_warning line by retyping it.** Copy it from the block above. A changed word or missing asterisk is enough for RedM to refuse the resource.
## Limitations
- It compares files by name and size, not by content. Two different files of the same size look the same.
- It does not read inside stream files, so it cannot tell you that two different `.ymap` files place objects in the same spot.
- It does not run Lua, so a script error, an event name clash or a missing dependency is not found.
- The game file check only covers names the game stores in readable form (see above).
## Related tools
- [server.cfg Generator](/redm/docs/tools/server-cfg-generator)
- [Hash Calculator](/redm/docs/tools/hash-calculator)
- [Imap Toggler](/redm/docs/tools/imap-toggler)
- [Folders to YTD](/redm/docs/tools/folders-to-ytd)
_Last updated: 2026-10-01_
---
## Item Generator
URL: https://fivemad.com/redm/docs/tools/item-generator
Pick RDR2 items by their game icon, edit names, labels and weights, and get the VORP items SQL or the RSG items.lua rows with the icons as PNG.
The Item Generator turns RDR2's own inventory icons into inventory items for your framework. Click the items you want, adjust the name, label and the framework's options, and copy the result: an `INSERT` statement for a VORP database, or rows for RSG's `shared/items.lua`. One more click downloads the icons as PNG, already in the folder your inventory reads, together with the SQL or Lua.
## What it is for
Adding items by hand means finding an icon, renaming it, and writing a database row or a Lua table entry with the right columns for your framework. The game already has icons for coffee, arrows, pelts, tonics and over a thousand other things, and for many of them it also has a proper name and description. This tool puts those together so you only choose.
## Quick start
1. Pick your framework on the right: **VORP (SQL)** or **RSG (items.lua)**.
2. Search the item list, or narrow it with a group chip (**Provisions**, **Consumables**, **Weapons** and so on).
3. Click items to add them. Click again to remove one. Picked items are outlined in red.
4. Edit each picked item: **Item** name, **Label**, **Description** and the framework's own fields.
5. Copy the code under the list, or press **Download icons and SQL** (or **Download icons and Lua**).
## The item list
There are **1,229** icons, every texture of the game's three inventory icon dictionaries. **763** of them have their own name in the game's English text and **404** also have a description. Turn on **Only items with a game label** to hide the ones without a name.
The group chips come from the start of the texture name, with their counts:
| Group | Icons | Group | Icons |
| --- | --- | --- | --- |
| Provisions | 369 | Ammo | 38 |
| Consumables | 214 | Kits | 37 |
| Clothing | 181 | Reinforced | 36 |
| Weapons | 85 | Upgrades | 32 |
| Generic | 58 | Collector | 20 |
| Online | 58 | Money | 7 |
| Documents | 48 | Vouchers | 6 |
| Folders | 39 | Other | 1 |
The search matches both the texture name and the label. The grid shows 96 icons at a time with a button for more.
## Editing a picked item
| Field | What it does | Default |
| --- | --- | --- |
| **Item** | The item's key: the name your scripts and the database use, and the icon's file name. At most 50 characters. | The texture name, cut to 50 characters |
| **Label** | The name players see. At most 50 characters. | The game's own label, or one made from the texture name |
| **Description** | The item description. | The game's own description, or empty |
| **Limit** (VORP) | How many a player can carry. | 10 |
| **Weight** (RSG, or VORP with the weight column on) | VORP uses a decimal, RSG a whole number. | 0.25 for VORP, 100 for RSG |
| **Usable** | Whether the item can be used. | on |
| **Can be dropped** (VORP) | Written as `can_remove`. | on |
| **Unique (does not stack)** (RSG) | Written as `unique`. | off |
A label made from the texture name drops a leading `consumable_`, `provision_`, `document_`, `kit_`, `upgrade_`, `generic_`, `clothing_`, `collector_` or `mp_` and capitalises the rest, so `ammo_bullet_express` becomes `Ammo Bullet Express`. Change it to something better before you ship.
Switching between VORP and RSG keeps your picks and resets every weight to that framework's default, because the two use different scales.
## VORP output
With **Coffee** and **Arrows** picked:
```sql title="items.sql"
-- Generated with fivemad.com/redm/tools/item-generator
-- Run it on your VORP database. Icons go in vorp_inventory/html/img/items/.png.
INSERT IGNORE INTO `items` (`item`, `label`, `limit`, `can_remove`, `type`, `usable`, `metadata`, `desc`) VALUES
('consumable_coffee', 'Coffee', 10, 1, 'item_standard', 1, '{}', 'Regular Coffee Brew. Moderately restores Stamina Core and Dead Eye Core.'),
('ammo_arrow', 'Arrows', 10, 1, 'item_standard', 1, '{}', 'Arrows');
```
These are the same columns the official VORP recipe uses for its own items. An item with no description gets its label as the description.
**Write the weight column** adds a `weight` column with each item's weight. Turn it on only if your `items` table has that column (newer VORP databases do, with a default of 0.25); on an older table the statement fails.
Run the SQL on your VORP database, put the icons in `vorp_inventory/html/img/items`, and restart the server.
## RSG output
The same two items for RSG:
```lua title="items.lua"
-- Generated with fivemad.com/redm/tools/item-generator
-- Paste these rows inside RSGShared.Items in rsg-core/shared/items.lua.
-- Icons go in rsg-inventory/html/images/.png.
consumable_coffee = { name = 'consumable_coffee', label = 'Coffee', weight = 100, type = 'item', image = 'consumable_coffee.png', unique = false, useable = true, shouldClose = true, description = 'Regular Coffee Brew. Moderately restores Stamina Core and Dead Eye Core.' },
ammo_arrow = { name = 'ammo_arrow', label = 'Arrows', weight = 100, type = 'item', image = 'ammo_arrow.png', unique = false, useable = true, shouldClose = true, description = '' },
```
The rows have the same shape as the items RSG ships with. Paste them inside the `RSGShared.Items = { ... }` table, put the icons in `rsg-inventory/html/images`, and restart rsg-core and the inventory.
## The download
**Download icons and SQL** (or **Lua**) gives you `redm-items-vorp.zip` or `redm-items-rsg.zip` with:
- every picked icon as a PNG, named after your **Item** name, inside `vorp_inventory/html/img/items/` or `rsg-inventory/html/images/`;
- `items.sql` or `items.lua`, the same code shown on the page.
Rename an item before you download and its icon follows. The icons are 192 pixels.
## Common mistakes
The warning panel catches these:
- **"... is picked twice."** Two picks with the same item name. The legendary animal carcasses are the usual case: names such as `provision_role_naturalist_carcass_bear_legendary_01`, `_02` and `_03` are longer than 50 characters, so all three are cut to the same name. Rename them, for example to `legendary_bear_pelt_1`.
- **"... use only letters, digits and underscores."** Spaces or dashes in an item name.
- **"... the item has no name."** An empty **Item** field.
And two it cannot catch:
- **The item exists already.** VORP's `INSERT IGNORE` skips a row whose item name is already in the table, so running the SQL again does not change an existing item. Edit or delete the old row first if you want new values.
- **The icon does not show.** The PNG has to be named exactly like the item and sit in the folder above. If you rename an item in the database later, rename the PNG too.
## Limitations
- Picks are not saved. Reloading the page empties the list, so copy or download before you leave.
- It writes plain items only: no weapons, ammo types, metadata or item use handlers. Those still need code in your framework.
- The labels and descriptions are the game's English text. Translate them yourself for another language.
## Related tools
- [Game Text Search](/redm/docs/tools/text-search)
- [server.cfg Generator](/redm/docs/tools/server-cfg-generator)
- [Hash Calculator](/redm/docs/tools/hash-calculator)
_Last updated: 2026-10-01_
---
## Hash Calculator
URL: https://fivemad.com/redm/docs/tools/hash-calculator
Turn RDR2 names into joaat hashes one at a time or as a list, and look a hash up against the names and game text read from RDR2's own files.
The Hash Calculator turns a name into the 32 bit joaat hash RDR2 uses for it, shows that hash as unsigned, signed and hex, and goes the other way too: paste a hash and it tells you which RDR2 name or game text label it belongs to, when it knows one.
## What it is for
RedM natives take model names, weapons, controls, scenarios and blip styles as hashes, and dumps and logs print them in whatever form they like. `3369743360`, `-925223936` and `0xC8DA3400` are the same horse. This page gives you every form of a hash at once, a table of hashes for a whole list of names, and a way to put a name back on a number you found in someone else's script.
RDR2 uses the same joaat as GTA V, hashed on the lower case name. In RedM that is `GetHashKey(name)`, `joaat(name)` or the Lua backtick shorthand `` `name` ``. What differs between the two games is which names exist, so the reverse lookup here searches RDR2 names, not GTA V ones.
## Quick start
1. Pick a tab: **Single**, **Bulk** or **Reverse lookup**.
2. In **Single**, type a name in **String**. The **Result** panel shows **Unsigned**, **Signed (int32)**, **Hex** and **Lua backtick**. Click any value to copy it.
3. In **Bulk**, paste one name per line. The table lists each name with its signed and hex hash, and the code block under it is a ready Lua table.
4. In **Reverse lookup**, paste a hash or a name into **Look up** and read the matches.
## Single
Type any string. It is hashed lower cased, exactly like `GetHashKey`, so `A_C_HORSE_ARABIAN_WHITE` and `a_c_horse_arabian_white` give the same result. The page opens on `a_c_horse_arabian_white`:
| Row | Value |
| --- | --- |
| **Unsigned** | `3369743360` |
| **Signed (int32)** | `-925223936` |
| **Hex** | `0xC8DA3400` |
| **Lua backtick** | `` `a_c_horse_arabian_white` `` |
The **Lua backtick** row is the name lower cased between backticks. RedM's Lua turns that into the hash when the script loads, so you never have to paste the number into code.
## Bulk
One string per line, blank lines are ignored. The panel title counts the hashes, the table shows **Name**, **Signed** and **Hex**, and **Export format** (**Hex**, **Signed** or **Unsigned**) decides what the generated table holds. The default sample and the default (hex) output:
```lua title="hashes.lua"
local Hashes = {
a_c_horse_arabian_white = 0xC8DA3400,
WEAPON_REVOLVER_CATTLEMAN = 0x169F59F7,
mp_male = 0xF5C1611E,
INPUT_JUMP = 0xD9D0E1C0,
WORLD_HUMAN_SMOKE = 0xFEA62BA1,
}
```
The keys keep the case you typed. Only the hash is computed from the lower case name.
## Reverse lookup
Paste up to 25 values, one per line (commas work too). Each value can be:
- an unsigned number (`3369743360`),
- a signed number (`-925223936`),
- `0x` hex (`0xC8DA3400`),
- or a name (`mp_male`), which is hashed first and then looked up, so you can check whether a name you have is one the game knows.
Every value gets its own panel. It says whether it was **Read as a hash** or **Read as a name**, shows the three forms of the hash, and lists every match with what kind of thing it is and an **Open** button that takes you to it on the RedM assets page or in the [Game Text Search](/redm/docs/tools/text-search).
The names searched are read from RDR2's own files. Today that is 28,747 names in 17 sets:
| Set | Names |
| --- | --- |
| Item | 13,085 |
| Map file (imap) | 5,124 |
| Scenario | 2,666 |
| Ped model | 1,982 |
| Game script | 1,889 |
| Timecycle modifier | 1,286 |
| Blip texture | 628 |
| Blip style | 620 |
| Document texture | 378 |
| Control (input) | 373 |
| Interior (MLO) | 278 |
| Weapon | 137 |
| Vehicle model | 115 |
| Map zone | 87 |
| Ammo type | 69 |
| Weather type | 22 |
| Prompt hold mode | 8 |
On top of those, a hash is checked against all 259,297 labels of the game's English text. A label hit is listed as **Game text label** with the text itself, for example `0x0000F96B` comes back as "Jumping Jeremiah!".
> [!NOTE]
> "No match" is common in RDR2 and does not mean your value is wrong. The game stores most of its names only as hashes, so plenty of real hashes have no known name at all. A model or item added by a custom resource will never be in this list either.
## Signed or unsigned
A joaat hash is an unsigned 32 bit number, but RedM natives and most dumps print it as a signed `int32`. Anything over `2147483647` comes out negative when printed signed. Both are the same hash: pass whichever your code or the native expects.
## Tips
- Use the **Lua backtick** form in Lua scripts. It is readable, it cannot be mistyped as a number, and it is hashed for you.
- When you find a bare number in an old script, paste it into **Reverse lookup** before guessing. If it is a label hash, the **Open** button shows you the full text.
- **Bulk** with **Signed** is handy when a config file or database column stores hashes as signed integers.
## Common mistakes
- **Hashing the display name.** `"Arabian"` is not a model name. Hash the model, weapon or control name the game uses (`a_c_horse_arabian_white`, `WEAPON_REVOLVER_CATTLEMAN`, `INPUT_JUMP`).
- **Comparing signed with unsigned.** `-925223936 == 3369743360` is false in code even though they are the same hash. Convert one side before comparing.
- **Taking a collision for an answer.** joaat is 32 bit, so two different names can share a value. When more than one name comes back, pick the one that fits what you are doing.
## Limitations
- The lookup only knows names that appear in RDR2's own files and that someone could put a name to. Many RDR2 hashes have no known name.
- It covers the sets listed above and the English game text. Anything else (sounds, animations, props) is not searched yet.
- When the same name is in two sets, or a name is also a text label key (`INPUT_JUMP` is a control and the label of the word "Jump"), the panel counts two matches and shows the collision note even though only one name is involved.
## Related tools
- [Game Text Search](/redm/docs/tools/text-search)
- [Prompt Builder](/redm/docs/tools/prompt-builder)
- [Blip Styles](/redm/docs/tools/blip-styles)
_Last updated: 2026-10-01_
---
## Game Text Search
URL: https://fivemad.com/redm/docs/tools/text-search
Search every line of RDR2's English text by words, label hash or key, see how the game stores it, and copy the Lua that replaces it in RedM.
Game Text Search looks through all 259,297 lines of RDR2's American English text: spoken dialogue, menus, prompts, item names and descriptions, help text and journal entries. Search by words, or find one label by its hash or its key, and copy a line of Lua that swaps that text for your own.
## What it is for
- Finding the label behind a piece of text you saw in game, so a script can replace or reuse it.
- Putting text on a label hash you found in a script or a dump.
- Checking how the game words something (an item, a prompt, a store) before you write your own UI to match it.
## Quick start
1. Type in the search box. It searches as you type once there are two characters.
2. Pick **All text**, **Spoken lines** or **Everything else**.
3. Click a result to open it. You get the hash in hex, unsigned and signed, the key when it is known, the text as the game stores it, and a `client.lua` line.
The search and the filter are kept in the URL (`?q=saloon&kind=dialogue`), so a link opens the same results.
## What you can type
| Input | Example | What happens |
| --- | --- | --- |
| Words | `saloon`, `moonshine still` | Every label whose text holds all the words, in any order. Case does not matter. |
| Hex hash | `0x0000F96B`, `0000F96B` | That one label, shown first. 8 hex digits work without `0x` when there is a letter in them. |
| Decimal hash | `63851` | The same label. Signed numbers work too. |
| Key | `BRT1_F_HARMOUTS` | The label whose key hashes to it, plus any text that contains the word. |
A word matches anywhere inside a line, so `saloon` also finds `saloons`. The key name is searched together with the text where it is known.
An exact hit (a hash or a key) is listed first and the panel title names it, for example `Label 0x0000F96B`. Word results follow in the order of their hashes, not by relevance.
## The filters
| Filter | Shows | Lines |
| --- | --- | --- |
| **All text** | Everything | 259,297 |
| **Spoken lines** | Subtitles of spoken dialogue | 183,520 |
| **Everything else** | Menus, prompts, items, help text, journal | 75,777 |
The filters apply to word results. An exact hash or key hit is always shown.
The page shows at most 100 rows. When there are more, the title says so (`294 matches, first 100`); add another word to narrow it down.
## Reading a result
Each row shows the label hash, the text, and under it the key or **key name not known**, plus **spoken line** for dialogue.
Only 27,294 of the 259,297 labels have a known key. The game stores a label under the hash of its key and the key itself is not in the files, so most labels are known only by their hash. That is normal, and the hash is all you need to replace the text.
The text in the list is cleaned for reading: `~n~` becomes a line break and the formatting codes (`~z~`, `~sl:...~` and similar) are taken out. When the stored text differs from what you see, the open row shows it under **As stored**. Named tokens such as `~INPUT_JUMP~` are kept, because the game draws a button there.
## Replacing a line
Every open result has a `client.lua` block. For the label `0x0000F96B`:
```lua title="client.lua"
-- replace this line of game text for everyone running the resource (Cfx native ADD_TEXT_ENTRY_BY_HASH)
AddTextEntryByHash(0x0000F96B, "~z~Jumping Jeremiah!")
```
The string is the text exactly as stored, codes included, so the line keeps its formatting until you change it. Edit the text between the quotes and put the line in a client script.
`AddTextEntryByHash` is a Cfx native (`ADD_TEXT_ENTRY_BY_HASH`). Cfx's native reference lists it with no game restriction, so it is there in RedM as well as FiveM. It only changes the text on the clients that run your resource.
> [!WARNING]
> This has not been tested in game for this page. Try it on one line on a test server before you build anything on it.
## Tips
- Keep the leading `~z~` on a spoken line when you replace it. That is how the game marks dialogue subtitles.
- `~n~` is a line break inside the text. Use it instead of a real new line in the Lua string.
- Got a hash from the [Hash Calculator](/redm/docs/tools/hash-calculator) that matched a **Game text label**? Its **Open** button lands on this page with the label already found.
## Limitations
- American English only. Other languages are not included.
- Text is read from the base game and the latest update (the update wins where both have a line). Text added by other resources is not here.
- Most labels have no known key name.
- Search is plain substring matching. There is no fuzzy matching, no stemming and no ranking.
- Replacing text with `AddTextEntryByHash` is not verified in game by fivemad.
## Related tools
- [Hash Calculator](/redm/docs/tools/hash-calculator)
- [Prompt Builder](/redm/docs/tools/prompt-builder)
- [Item Generator](/redm/docs/tools/item-generator)
_Last updated: 2026-10-01_
---
## Interactive Map
URL: https://fivemad.com/redm/docs/tools/map
Browse the RDR2 map in 2D or 3D, jump to a town or a lake, show the game's zone outlines and read the world position and zones under your cursor.
The Interactive Map is the RDR2 map drawn from the game's own files, with the world position under your cursor, the game's own zone outlines (states, districts, towns, water) and a place search. It is the same map every RedM map tool on the site draws on, so what you learn here works in the Coords Picker, Blip Placer and Door Finder too.
## What it is for
Finding where something is before you script it. Look up a town, see which district and state a spot belongs to, read the x and y your script needs, or fly around in 3D to check the ground and the buildings. When you want to copy a position, open the [Coords Picker](/redm/docs/tools/coords-picker).
## Quick start
1. Drag to pan, scroll or pinch to zoom, or use the **+** and **-** buttons in the top right corner.
2. Type a name in **Go to a place** (for example `Valentine` or `Flat Iron Lake`) and click a result. The map flies there.
3. Turn zone outlines on and off under **Zones on the 2D map**.
4. Move the mouse over the map. The position shows in the bottom right corner of the map and in the **Under the cursor** panel, with every zone that covers that spot.
5. Press **Pick coordinates** when you want to copy a point.
## The map toolbar
The buttons in the top left corner of the map:
| Control | What it does | Default |
| --- | --- | --- |
| **2D** / **3D** | Flat map, or the same map laid over the game's heightmap in 3D. | 2D |
| **Mainland** / **Guarma** | Which map to show. Guarma is its own map, far south of the mainland. Switching opens the other one on its own ground. | Mainland |
| **Terrain** / **Paper** | Terrain shows the relief. Paper is the look of the in-game pause map. | Terrain |
| **Reference points** | Pins on 11 known spots (the five banks, Annesburg, Strawberry, Tumbleweed, Van Horn, Colter, Sisika) so you can check the map lines up. 2D only. | off |
Switching style, or going to 3D and back, keeps the place you were looking at.
## 3D view
Press **3D** to see the terrain in relief. If you were zoomed in on the 2D map, 3D opens over that spot; if you were looking at the whole map, it opens on the whole map. The ground in 3D shows the game's own terrain colours, with lakes and rivers in the map's water colour, whichever 2D style you picked.
- **Drag** to turn, **right drag** to move, **wheel** to zoom.
- **Height x1.0** stretches the terrain up to four times, in steps of 0.5, which helps on flat ground.
- Buildings and trees fill in over the whole map in low detail first, and stay when you zoom out. Then the full detail buildings and trees keep loading from any distance, starting with what you look at, until your device has as much as it can hold; the full detail ground loads within a few kilometres and interiors close up. Full detail fades in over its low detail. Nothing is dropped when you zoom out, and nothing on screen is taken away for something else.
- While the camera is still nothing switches off; newly loaded detail only fades in. What is drawn is chosen again when you move. How much full detail is drawn at once depends on your device, so the view stays smooth: a strong graphics card shows more of it from far away.
- **Buildings: Interiors / Trees** chooses whether full detail interiors and trees load. Both are on. Turn one off if 3D feels slow; the low detail trees stay.
- While something loads, the corner says what and how many are still to come.
The zone outlines, the place search and the reference points are 2D only.
## Go to a place
The list holds the 24 towns, 35 water bodies (lakes, rivers, creeks, ponds, a swamp and an ocean) and the 5 bank locations plus Colter, 65 entries in all, sorted into **Place**, **Town** and **Water**. Search matches any part of the name. Clicking a town or place zooms in close; clicking water stops further out, because lakes and rivers are large. The Guarma entries (Manicato, the three Aguasdulces places, Bahia de la Paz and Arroyo de la Vibora) switch the map to **Guarma** first, and a mainland entry switches it back.
## Zones on the 2D map
| Layer | What it draws | Default |
| --- | --- | --- |
| **Towns** | Town outlines with their names. | on |
| **Districts** | Districts (The Heartlands, Big Valley, Bayou Nwa...), dashed. | off |
| **States** | States (New Hanover, Lemoyne, New Austin...), thicker red line. | off |
| **Water** | Lakes, rivers, creeks, ponds, the swamp and the ocean. | off |
Town names are always labelled. District, state and water names appear once you zoom in a little.
These are the game's own zones from `mapzones.meta`: 9 states, 19 districts, 24 towns and 35 water bodies. They are the polygons the game's zone natives answer from, so a point inside the Valentine outline on this map is a point the game calls Valentine.
## Under the cursor
The panel shows the cursor's x and y (one decimal), the z when the height under it is known, and every zone that covers the spot with its type (`state`, `district`, `town`, `lake`, `river`...). Outside every zone it says so.
The numbers are world metres, the same x and y RedM scripts use. The small readout in the map corner rounds to whole metres.
## Tips
- Want the zone hash for a script check, or a z you can paste? Use the [Coords Picker](/redm/docs/tools/coords-picker): it shows the same zones with their hashes and the Lua to test them.
- Turn on **States** and **Districts** together to see how the game nests them: every district sits inside a state.
- Use **Paper** when you want to compare with what players see on their pause map.
## Limitations
- The z in the cursor readout is the top of an 8 m height cell, which includes roofs and tree tops. It is a guide, not a spawn height.
- In 3D, buildings and trees only appear where they are available for that area, and they load in as you move.
- The low detail is plain coloured buildings, larger structures and simple tree shapes. Small props only show in full detail, close up.
## Related tools
- [Coords Picker](/redm/docs/tools/coords-picker)
- [Blip Placer](/redm/docs/tools/blip-placer)
- [Door Finder](/redm/docs/tools/door-finder)
- [Interiors](/redm/docs/tools/interiors)
- [Train Tracks](/redm/docs/tools/train-tracks)
_Last updated: 2026-10-02_
---
## Coords Picker
URL: https://fivemad.com/redm/docs/tools/coords-picker
Click the RDR2 map for x, y, z and a heading, copy them as vector3, vector4 or JSON, and get the state, district, town and water zone at that spot.
The Coords Picker turns a click on the RDR2 map into a position your script can use: x, y, a z read from the game's heightmap, and a heading you aim by dragging. Copy it as `vector3`, `vector4`, JSON or a bare `x, y, z`. It also tells you which state, district, town and water body the point is in, with the zone hashes and the Lua to check them.
## What it is for
Spawn points, shop positions, teleport targets, zone checks. Instead of walking there in game and printing your coords, click the spot on the map, copy the line and paste it into your config. Then fine tune z in game.
## Quick start
1. Click the map. A numbered point drops there and opens in the **Point 1** panel.
2. To set a heading, press on the selected point and drag in the direction it should face.
3. Pick **Ground** or **Top** for z, or type your own.
4. Press **vector3**, **vector4**, **JSON** or **x, y, z** to copy the point.
5. Keep clicking to add more points. With two or more, a Lua table of all of them appears under **Points**.
The map has the same **Mainland** / **Guarma**, **Terrain** / **Paper** and **Reference points** buttons as the [Interactive Map](/redm/docs/tools/map), but no 3D view.
## The point panel
| Field or button | What it does |
| --- | --- |
| **x**, **y** | The world position, rounded to two decimals. You can type over them. |
| **z** | The height. Filled from **Ground** when you click; typing a value keeps yours. |
| **heading** | 0 to 360. Set by dragging from the point, or typed. |
| **Ground** / **Top** | The two heights the game's heightmap stores for the 8 m cell under the point. Shows `?` and is disabled where no height is known. |
| **Center** | Moves the map back to this point. |
| **vector3** / **vector4** / **JSON** / **x, y, z** | Copy the point in that format. The `vector4` line is also shown under the buttons. |
Heading counts the way `GetEntityHeading` does: 0 is north, 90 is west, 180 is south, 270 is east.
For a point clicked at the Valentine bank, with Ground picked and no heading set, the four buttons copy:
```text
vector3(-308.42, 775.88, 115.5)
vector4(-308.42, 775.88, 115.5, 0.0)
{"x":-308.42,"y":775.88,"z":115.5,"heading":0}
-308.42, 775.88, 115.5
```
## Where z comes from
The game's heightmap keeps two numbers for every 8 m cell: the lowest point (**Ground**) and the highest (**Top**, which includes roofs and tree tops). Ground is picked by default because it is usually what you want for a ped or a prop outside.
At the Valentine bank, for example, Ground is 115.5 and Top is 125, while the bank's front doors sit at 117.73. Inside a town or on a slope the real floor can be a few metres off either number. Treat z as a starting point, stand there in game, and type the exact value.
## Zones here
Under the copy buttons, **Zones here** lists every zone of the game's `mapzones.meta` that covers the point, with its name, type, hash in hex and the signed hash (with a copy button). Under the list is Lua that checks each one with `_GET_MAP_ZONE_AT_COORDS`. For the Valentine bank:
```lua
-- _GET_MAP_ZONE_AT_COORDS (0x43AD8FC02B429D33), type 0 = STATE
if Citizen.InvokeNative(0x43AD8FC02B429D33, x, y, z, 0) == -1289136221 then -- NewHanover
end
-- _GET_MAP_ZONE_AT_COORDS (0x43AD8FC02B429D33), type 10 = DISTRICT
if Citizen.InvokeNative(0x43AD8FC02B429D33, x, y, z, 10) == 131399519 then -- Heartlands
end
-- _GET_MAP_ZONE_AT_COORDS (0x43AD8FC02B429D33), type 1 = TOWN
if Citizen.InvokeNative(0x43AD8FC02B429D33, x, y, z, 1) == 459833523 then -- valentine
end
```
`x, y, z` are yours to fill in, usually the player's coords. The native returns the hash of the zone of that type at the position, and the hash is `joaat` of the zone name. The type numbers used: 0 state, 1 town, 2 lake, 3 river, 5 swamp, 6 ocean, 7 creek, 8 pond, 10 district.
The town the point is in is also outlined on the map.
## The points list
**Points (n)** lists everything you have picked as `x, y, z, heading`. Click a row to select that point and fly to it (a point picked on Guarma switches the map to **Guarma**, and the other way round), press the bin icon to remove it, or **Clear** to remove them all. Points are kept in this browser, so they are still there when you come back.
With two or more points you get a table of them, ready for a list of spawn points or a route. Here the Valentine bank, then the Rhodes bank with a heading of 90 (facing west):
```lua
local points = {
vector4(-308.42, 775.88, 115.5, 0.0),
vector4(1292.31, -1301.54, 72.5, 90.0),
}
```
## Tips
- Zoom in before you click. At full map zoom one pixel is many metres.
- Drag the heading from a little way out. The direction from the point to the pointer is what counts, not how far you drag.
- To check which zones cover a whole area, use the zone layers on the [Interactive Map](/redm/docs/tools/map) instead.
## Common mistakes
- **Ped spawns on the roof or in a tree.** You copied **Top** instead of **Ground**. Switch to Ground, or type the height you measured in game.
- **Ped falls through the floor indoors.** The heightmap knows nothing about interior floors. Stand in the room in game and use that z.
- **Zone check never matches.** Compare against the signed hash (`-1289136221`, not `3005831075`), and pass the right type number for the zone you want.
## Limitations
- z is only as good as an 8 m height grid. It is not a ground probe.
- A point is only drawn on the map it was picked on, so Guarma points show while **Guarma** is open and mainland points while **Mainland** is open. The list and the Lua table always hold all of them.
- The tool does not know about interiors, bridges or anything else stacked over the ground.
## Related tools
- [Interactive Map](/redm/docs/tools/map)
- [Blip Placer](/redm/docs/tools/blip-placer)
- [Door Finder](/redm/docs/tools/door-finder)
- [Interiors](/redm/docs/tools/interiors)
_Last updated: 2026-10-01_
---
## Blip Placer
URL: https://fivemad.com/redm/docs/tools/blip-placer
Place blips on the RDR2 map with the game's own blip styles and icons, then copy a Lua client script, a vorp_stores Blip block or rsg-shops blip fields.
The Blip Placer lets you drop blips on the RDR2 map, pick a style and an icon for each one from the game's own lists, and copy the result as a Lua client script or as the blip part of a vorp_stores or rsg-shops config entry.
## What it is for
Laying out a set of map icons (shops, stables, camps, job spots) by looking at the map instead of copying coordinates around. You see where each blip lands next to the towns and roads, and you get the config block in the shape your shop resource expects.
## Quick start
1. Pick a **Style** and an **Icon** in the **New blips** panel, and set the **Scale**.
2. Click the map. A blip with those settings drops there.
3. Rename it in **Label**. Drag it on the map to move it.
4. Click more spots for more blips.
5. Choose an output tab, **Lua**, **vorp_stores** or **rsg-shops**, and copy the code.
## Style and icon
In RDR2 a blip is created from a **style**: an entry of the game's `blipdata.ymt` that decides the icon, the colour and the label. Once it exists, `SET_BLIP_SPRITE` can give it another icon.
| Option | What it does | Default |
| --- | --- | --- |
| **Label** | The blip's name on the map. Shown when a blip is selected. | `Blip 1`, `Blip 2`... |
| **Style (blipdata.ymt)** | The style to create the blip with. The list holds the 261 styles that draw an icon. Search by style name or label. | `BLIP_STYLE_PICKUP_WEAPON` |
| **Icon** | Another icon for the blip, from the game's 628 blip textures, or **The style's own icon** to keep the style's. Search by texture name or dictionary. | `blip_shop_store` |
| **Scale** | Blip size, 0.1 to 1.5 in steps of 0.05. | 0.2 |
Both pickers show up to 80 matches at a time, so type a few letters to narrow them down.
When a blip is selected, the panel says **Editing** and the blip's name, and your changes go to that blip. A style, icon or scale you pick also becomes the setting for the next blip you place, so a row of shop blips only needs setting up once.
Opening the Blip Placer from **Place it on the map** in [Blip Styles](/redm/docs/tools/blip-styles) starts with that style and its own icon.
## On the map
- **Click** an empty spot to place a blip.
- **Drag** a blip to move it. Its z is read again where you drop it.
- Labels show next to the selected blip, and next to every blip once you zoom in.
The map has the same region, style and **Reference points** buttons as the [Interactive Map](/redm/docs/tools/map), but no 3D view.
z is the ground height from the game's heightmap. A blip barely needs one, but the config formats ask for it.
The **Blips (n)** list shows every blip with its icon. Click a name to select it and fly to it (a blip placed on Guarma switches the map to **Guarma**, and the other way round), press the bin icon to remove it, or **Clear** to remove them all. Blips are kept in this browser.
## The outputs
The code for every blip on the map, in one of three shapes. Under the code, **Style hashes** lists the hex hash of each style you used.
### Lua
A client script that creates every blip when the resource starts and removes them when it stops. One blip with the default settings, placed at the Valentine bank:
```lua title="client.lua"
local blips = {
{ name = "Blip 1", style = 1664425300, sprite = 1475879922, scale = 0.2, coords = vector3(-308.42, 775.88, 115.5) }, -- BLIP_STYLE_PICKUP_WEAPON, blip_shop_store
}
local made = {}
CreateThread(function()
for _, b in ipairs(blips) do
-- BLIP_ADD_FOR_COORDS (0x554D9D53F696D002): the style decides the icon, colour and label
local blip = Citizen.InvokeNative(0x554D9D53F696D002, b.style, b.coords.x, b.coords.y, b.coords.z)
-- SET_BLIP_SPRITE (0x74F74D3207ED525C): another icon than the style's own
if b.sprite then Citizen.InvokeNative(0x74F74D3207ED525C, blip, b.sprite, true) end
-- SET_BLIP_SCALE (0xD38744167B2FA257)
Citizen.InvokeNative(0xD38744167B2FA257, blip, b.scale)
-- _SET_BLIP_NAME (0x9CB1A1623062F402)
Citizen.InvokeNative(0x9CB1A1623062F402, blip, b.name)
made[#made + 1] = blip
end
end)
AddEventHandler("onResourceStop", function(res)
if res ~= GetCurrentResourceName() then return end
for _, blip in ipairs(made) do RemoveBlip(blip) end
end)
```
A blip set to **The style's own icon** gets `sprite = nil`, and the script skips `SET_BLIP_SPRITE` for it.
### vorp_stores
The `Blip` block of a store in vorp_stores' `config.lua`. That resource keeps the icon as a sprite hash and picks the style itself, so only the name, the icon and the position are written:
```lua
Blip = {
Allowed = true,
Name = "Blip 1",
sprite = 1475879922, -- blip_shop_store
Pos = vector3(-308.42, 775.88, 115.5),
},
```
### rsg-shops
The blip fields of a `Config.StoreLocations` entry in rsg-shops' `config.lua`. The other fields of the entry (the shop's own settings) are not written, so paste these into an entry you already have. rsg-shops draws its blips with style `1664425300` (`BLIP_STYLE_PICKUP_WEAPON`) and takes the icon by name:
```lua
{
label = 'Blip 1',
shopcoords = vec3(-308.42, 775.88, 115.5),
blipsprite = 'blip_shop_store',
blipscale = 0.2,
showblip = true,
},
```
With a blip on **The style's own icon**, the vorp_stores and rsg-shops outputs write the style's icon instead, because neither resource lets you choose the style.
## Tips
- Pick the style for its colour and its label, then pick the icon you want shown. A style's icon can always be overridden.
- Use [Blip Styles](/redm/docs/tools/blip-styles) to look a style up first: it shows the icon, the colour and what the style inherits.
- The selected blip's position is printed under **Scale**, if you want to check it before copying.
## Common mistakes
- **The style you picked does not show with vorp_stores or rsg-shops.** Those resources only take the icon (and for rsg-shops the scale) from your config. The style is their own choice.
## Limitations
- The map shows each blip's icon, not the colour the style gives it in game.
- A blip is only drawn on the map it was placed on, so Guarma blips show while **Guarma** is open. The list and the code always hold all of them.
- The tool does not preview how a blip looks in game.
## Related tools
- [Blip Styles](/redm/docs/tools/blip-styles)
- [Blip Replacer](/redm/docs/tools/blip-replacer)
- [Coords Picker](/redm/docs/tools/coords-picker)
- [Interactive Map](/redm/docs/tools/map)
_Last updated: 2026-10-01_
---
## Blip Styles
URL: https://fivemad.com/redm/docs/tools/blip-styles
Browse all 620 blip styles of RDR2's blipdata.ymt: the icon and colour each one ends up with, the styles it inherits from, and the Lua to create a blip with it.
Blip Styles lists every blip style in RDR2's `blipdata.ymt`, 620 of them, with the icon, colour and label each one really ends up with. Click one for its hash, the chain of styles it inherits from, and a line of Lua that creates a blip with it.
## What it is for
In RDR2 a blip is created from a style, and the style decides the icon, the colour and the label. Scripts pass styles around as hashes, so a line like `BLIP_ADD_FOR_COORDS(1664425300, ...)` tells you nothing. Here you can find a style by what it looks like, or look up a hash you found in somebody's script.
## Quick start
1. Search for a style name, a texture, a label or a hash, or click a category chip.
2. Click a card. Its details open on the right.
3. Copy the signed hash, or copy the Lua block.
4. Press **Place it on the map** to start the [Blip Placer](/redm/docs/tools/blip-placer) with this style.
## Searching and filtering
| Control | What it does | Default |
| --- | --- | --- |
| Search box | Matches part of the style name, the icon texture or the label. A whole hash matches too: the hex form with its `0x` (`0x63351D54`) or the decimal one, signed or unsigned. | empty |
| **Only styles that draw an icon** | Hides the styles that have no icon of their own. | on |
| Category chips | **All**, plus one chip per category the game gives a style (Mission active, Objective, Pickups, Enemy...) with its count. | All |
Of the 620 styles, 261 draw an icon and 359 do not. The ones without are modifiers and parents (for example `BLIP_MODIFIER_SHOP_UNAVAILABLE`, which only sets a colour), so they are hidden until you untick the filter. 216 styles carry a category, in 28 categories; the rest have none and only show under **All**.
The line above the grid says how many styles match, for example `261 of 620 styles`. The grid shows 60 at a time, with **Show more** under it.
The open style is kept in the URL (`?id=BLIP_STYLE_PICKUP_WEAPON`), so you can link to it.
## The style panel
| Field | What it shows |
| --- | --- |
| Name and label | The style name, and the label it shows on the map (or **No label**). |
| **Hash** | The hash in hex, and a button that copies the signed decimal value. |
| **Icon** | The blip texture the style draws, or none. |
| **Colour** | The colour name it uses (`COLOR_WHITE`, `COLOR_FRIENDLY`...), or none. |
| **Category** | Its category, or none. |
| **Inherits from** | The style, its parent, the parent's parent, and so on. Click one to open it. |
### Styles inherit
Every style can name a parent, and takes every setting it does not set itself from it. The icon, colour and label shown on the card and in the panel are what the style ends up with after that chain, and **Inherits from** lists the chain so you can see where each value comes from. The longest chain is six styles deep.
For example `BLIP_STYLE_HONOR_SHOP` inherits from `BLIP_STYLE_SHOP`, which inherits from `DEFAULT_COORDS`. It changes the icon to `blip_shop_honor` and the colour to `COLOR_RED`.
## The Lua
Every style comes with the call that creates a blip from it. For `BLIP_STYLE_PICKUP_WEAPON`:
```lua
-- BLIP_ADD_FOR_COORDS (0x554D9D53F696D002): BLIP_STYLE_PICKUP_WEAPON
local blip = Citizen.InvokeNative(0x554D9D53F696D002, 1664425300, x, y, z) -- 0x63351D54
```
`x, y, z` are yours to fill in. The style hash works the same with the other `BLIP_ADD` natives. To give the blip a different icon or a name afterwards, see the full script the [Blip Placer](/redm/docs/tools/blip-placer) writes.
## Tips
- Looking up a hash from someone else's script? Paste it in the search box as it is: signed, unsigned, or hex with the `0x`.
- Pick a style for its colour and its label, then set the icon you want with `SET_BLIP_SPRITE`. That is what rsg-shops does with its store blips.
- Untick **Only styles that draw an icon** when you are looking for a modifier or a parent style.
## Limitations
- The icon on a card is the texture alone. The colour the game tints it with is listed by name, not drawn.
- Category and colour names are the game's own internal names. Not every style has a category, a colour or a label.
- The tool does not say what a style does in game beyond its icon, colour, label and category.
## Related tools
- [Blip Placer](/redm/docs/tools/blip-placer)
- [Blip Replacer](/redm/docs/tools/blip-replacer)
- [Hash Calculator](/redm/docs/tools/hash-calculator)
_Last updated: 2026-10-01_
---
## Door Finder
URL: https://fivemad.com/redm/docs/tools/door-finder
Find any RDR2 door on the map, get its door hash and position, and copy it as a vorp_doorlocks or rsg-doorlock config entry or as Lua that locks it.
The Door Finder shows every door RDR2 registers with its door system on the map: 1,901 doors with 1,846 different door hashes. Click a door to get its hash, position and heading, and copy it as a `Config.Doors` entry for vorp_doorlocks, a `Config.DoorList` entry for rsg-doorlock, or Lua that locks it.
## What it is for
Every door lock resource needs the door's hash, and RDR2 does not work it out at runtime: each door in the world carries its own hash. Normally you would stand at the door in game with a debug script. Here you find the door on the map, check it is the right one, and paste the entry.
## Quick start
1. The map opens on Valentine, close enough to see the doors. Pan to the building you want, or search for it.
2. Click a door. Its hash, position and heading show on the right.
3. Hold **Shift** and click more doors to select several, for example both leaves of a double door.
4. Pick the output tab: **vorp_doorlocks**, **rsg-doorlock** or **Lua**.
5. Copy the code and set the permissions or jobs to your own.
## On the map
| Marker | Meaning |
| --- | --- |
| Blue dot | A door placed by a map file (a gate, a shed, a house front). |
| Orange dot | A door that belongs to an interior. |
| White dot | A door you have selected. |
Zoom in and every door also gets a short bar showing which way it faces, which is how you tell the two leaves of a double door apart.
**Click** selects the door nearest to the pointer (within a few pixels) and drops the rest of the selection. **Shift click** adds a door to the selection, or takes it out again if it was already in.
## Search and filters
| Control | What it does | Default |
| --- | --- | --- |
| Search box | Matches part of the door's model name or interior name, or a whole door hash: decimal (signed or unsigned) or 8 digit hex, with or without `0x`. | empty |
| **All** / **Map files** / **Interiors** | Show every door, only the 786 placed by map files, or only the 1,115 inside interiors. | All |
The line under the chips says how many doors match. While the search box has text, up to 100 matching doors are listed under it with their interior name (or their x, y when they are outside); click one to select it and fly to it. The filters apply to the map too, so a search also thins out the markers.
You can link to a search with `?q=` or straight to a door with `?door=`.
## The door panel
| Field | What it shows |
| --- | --- |
| Name | The door's model name. 173 doors have no known model name and show `model 0x...` with the model hash instead. |
| **Door hash** | The hash in decimal, with a copy button, and in hex. This is the number door lock resources want. |
| **Position** | x, y, z of the door, with a **vector3** copy button. |
| **Heading** | The door's heading in degrees. |
| **Model hash** | The model's hash in hex. |
| **Interior** | The interior the door belongs to, linking to it in the [Interiors](/redm/docs/tools/interiors) tool. |
Two notes can appear under it:
- **The map file that places this door is only loaded when a script asks for it.** 353 doors are like this. Until something loads that map file, the door is not in the world, so locking it does nothing.
- **The game places this interior n times, so this hash is at n places.** A few interiors (a riverboat, some shacks) are placed more than once, and their doors carry the same hash in every copy. 110 doors are like this, so check the position in your config is the copy you mean.
With more than one door selected the panel just says how many, and the outputs cover all of them.
## The outputs
The examples below are the two front doors of the Valentine bank (`p_door_val_bank00_lx` and `p_door_val_bank00_rx`), selected together.
### vorp_doorlocks
Entries for `Config.Doors` in vorp_doorlocks' `config.lua`, keyed by door hash. Set `Permissions` to one of your `Config.Permissions` groups.
```lua
[2642457609] = {
Pos = vector3(-309.05, 779.73, 117.73),
Name = "p_door_val_bank00_lx",
DoorState = 1, -- 0 open, 1 closed
Permissions = false, -- or a Config.Permissions entry
BreakAble = false,
Difficulty = 3,
Alert = false,
},
[3886827663] = {
Pos = vector3(-306.88, 780.12, 117.73),
Name = "p_door_val_bank00_rx",
DoorState = 1, -- 0 open, 1 closed
Permissions = false, -- or a Config.Permissions entry
BreakAble = false,
Difficulty = 3,
Alert = false,
},
```
### rsg-doorlock
Entries for `Config.DoorList` in rsg-doorlock's `config.lua`. Every entry starts with `authorizedJobs = { 'police' }`: put your own job names there. `textCoords` is the door position one metre up, and `objYaw` is the heading written from -180 to 180.
```lua
{ -- p_door_val_bank00_lx
authorizedJobs = { 'police' },
doorid = 2642457609,
objCoords = vector3(-309.05, 779.73, 117.73),
textCoords = vector3(-309.05, 779.73, 118.73),
objYaw = 10.1,
locked = true,
distance = 2.0
},
{ -- p_door_val_bank00_rx
authorizedJobs = { 'police' },
doorid = 3886827663,
objCoords = vector3(-306.88, 780.12, 117.73),
textCoords = vector3(-306.88, 780.12, 118.73),
objYaw = -169.9,
locked = true,
distance = 2.0
},
```
### Lua
A client script that registers the doors with the door system (when the game has not already) and locks them:
```lua title="client.lua"
local doors = {
2642457609, -- p_door_val_bank00_lx at -309.0, 779.7
3886827663, -- p_door_val_bank00_rx at -306.9, 780.1
}
CreateThread(function()
for _, door in ipairs(doors) do
-- _ADD_DOOR_TO_SYSTEM_NEW (0xD99229FE93B46286)
if not Citizen.InvokeNative(0xC153C43EA202C8C1, door) then -- IS_DOOR_REGISTERED_WITH_SYSTEM
Citizen.InvokeNative(0xD99229FE93B46286, door, true, true, false, 0, 0, false)
end
-- DOOR_SYSTEM_SET_DOOR_STATE (0x6BAB9442830C7F53): 1 locks it, 0 unlocks it
Citizen.InvokeNative(0x6BAB9442830C7F53, door, 1)
end
end)
```
Change the `1` in the last call to `0` to unlock instead.
## Tips
- Double doors are two doors with two hashes. Shift click both leaves, or one side stays open.
- Not sure you have the right building? Pick **Interiors** and search for the interior name (`val_bank`, `rho_sheriff`), then check the doors that are left.
- A door hash from someone's config can be pasted into the search box to see which door it is and where.
## Common mistakes
- **Only half of a double door locks.** You copied one leaf. Select both.
- **The lock does nothing.** Check for the note about a map file that only loads when a script asks. That door is not there until the map file is loaded.
- **Everyone can open the door.** The vorp_doorlocks entries come with `Permissions = false` and the rsg-doorlock entries with the `police` job. Set them to your own before you use them.
## Limitations
- The door lists come from the game's own map and interior files. Doors that a script spawns at runtime are not in them.
- The position is the door entity's own position, as the game places it. Move rsg-doorlock's `textCoords` yourself if the text should sit somewhere else.
- The tool does not check your door lock resource's config format beyond the entries it writes. If your fork of vorp_doorlocks or rsg-doorlock uses other field names, rename them.
## Related tools
- [Interiors](/redm/docs/tools/interiors)
- [Imap Toggler](/redm/docs/tools/imap-toggler)
- [Coords Picker](/redm/docs/tools/coords-picker)
- [Interactive Map](/redm/docs/tools/map)
_Last updated: 2026-10-01_
---
## Imap Toggler
URL: https://fivemad.com/redm/docs/tools/imap-toggler
Find RDR2 imaps (ymaps) by clicking the map, by name or by hash, see which only load when a script asks, and copy Lua that loads or removes them.
The Imap Toggler lists every imap (ymap) RDR2 ships, 7,516 of them, with the area its entities cover drawn on the map. Click a spot to see which imaps sit there, or search by name or hash, tick the ones you want and copy Lua that loads them, removes them or toggles them with a chat command.
## What it is for
An imap is a piece of the world: a house, a camp, a pile of props, a burnt or a rebuilt version of a building. 2,639 of the game's imaps only stream when a script asks for them, so if you want one of those in your RedM world, your resource has to request it. The reverse also works: remove an imap that is loaded and its contents are gone.
The hard part is knowing which imap holds the thing you are looking at. This tool answers that from the map.
## Quick start
1. Zoom in on the place you care about. Once you are close enough, each imap shows as a box (only the script loaded ones while **Only imaps loaded by script** is ticked).
2. Click the spot. The list on the right now holds only the imaps whose box covers that point, smallest first.
3. Click a name in the list to fly to it and open its details.
4. Tick the box in front of each imap you want. They collect in the **Set** panel.
5. Pick **Load**, **Remove** or **Toggle command** and copy the code.
## Finding an imap
| Control | What it does | Default |
| --- | --- | --- |
| **Name or hash** | Search box. See the table below for what it matches. | empty |
| **Only imaps loaded by script** | Limits the list (and the boxes on the map) to the 2,639 imaps that only load when a script asks. Untick it to include the 4,877 that load with the world. | on |
| Click on the map | Keeps only the imaps whose box covers that point, smallest first. The point shows as **Covering x, y** with an **x** button to clear it. | none |
The search and the map click work together, so you can click a spot and then type to narrow it.
| You type | It matches |
| --- | --- |
| Part of a name, `lockdown` | Every imap whose name contains it |
| A hex hash, `89648C4A` or `0x89648C4A` | That imap. Write all 8 digits when you leave out `0x`. |
| A decimal hash, `-1989899190` or `2305068106` | That imap, signed or unsigned |
The list shows at most 200 rows and says how many more there are. Each row is tagged **script** (loads only when asked) or **always** (loads with the world).
## The map
- Boxes appear once you zoom in. Orange boxes only load when a script asks, faint white ones load with the world.
- Imaps in your set are green.
- The imap you opened is white.
- The white dot is the point you clicked.
The box is where the imap's entities sit, rounded to the metre. It is not a streaming radius.
## Details
Clicking a name opens its card:
| Field | What it shows |
| --- | --- |
| **Hash** | Hex and signed decimal, for example `0x89648C4A / -1989899190` |
| **Loaded** | **only when a script asks** or **with the world** |
| **Extents** | The x, y box and the z range of its entities |
| **Contents** | How many entities it places, plus instanced plants and rocks when it has any |
| **Parent** | The imap it hangs off, when it has one |
**Add to the set** / **Remove from the set** does the same as the tick box.
## The code
The **Set** panel turns your picks into one table of signed hashes with each name in a comment, and a loop over it. **Clear** empties the set.
| Mode | What the code does |
| --- | --- |
| **Load** | Requests every imap in the set that is not active yet |
| **Remove** | Removes every imap in the set that is active |
| **Toggle command** | Registers an `/imaps` command that removes each imap if it is active and requests it if not |
The natives are called by hash with `Citizen.InvokeNative`, each one named in a comment. With `VAL_02_LOCKDOWN_BANK` and its parent in the set, **Load** gives:
```lua title="client.lua"
local imaps = {
-1989899190, -- VAL_02_LOCKDOWN_BANK
84505049, -- val_02_lockdown_bank_lod
}
for _, imap in ipairs(imaps) do
-- IS_IPL_ACTIVE_HASH (0xD779B9B910BD3B7C), REQUEST_IPL_HASH (0x59767C5A7A9AE6DA)
if not Citizen.InvokeNative(0xD779B9B910BD3B7C, imap) then
Citizen.InvokeNative(0x59767C5A7A9AE6DA, imap)
end
end
```
and **Toggle command** gives:
```lua title="client.lua"
local imaps = {
-1989899190, -- VAL_02_LOCKDOWN_BANK
84505049, -- val_02_lockdown_bank_lod
}
RegisterCommand("imaps", function()
for _, imap in ipairs(imaps) do
-- IS_IPL_ACTIVE_HASH (0xD779B9B910BD3B7C)
if Citizen.InvokeNative(0xD779B9B910BD3B7C, imap) then
Citizen.InvokeNative(0x5A3E5CF7B4014B96, imap) -- REMOVE_IPL_HASH
else
Citizen.InvokeNative(0x59767C5A7A9AE6DA, imap) -- REQUEST_IPL_HASH
end
end
end, false)
```
These are client natives, so the code goes in a client script and runs on each player's game.
## Names and hashes
5,124 imaps have a known name. The other 2,392 (about a third) are listed by hash, as `0x...`. That matters more than it sounds with the default filter on: of the 2,639 imaps that only load on request, 2,083 are known only by hash.
A missing name does not stop you. The natives take the hash, and the code always writes the hash, so an unnamed imap loads and unloads exactly like a named one. The name is only there to help you recognise it.
## Tips
- Click the spot, then look at the smallest boxes first. The list is sorted that way because a small imap is usually the specific thing you clicked on, while the big ones cover a whole area.
- Many imaps name a **Parent**, often the `_lod` imap of the same name (`VAL_02_LOCKDOWN_BANK` hangs off `val_02_lockdown_bank_lod`). When you load one, look at its parent too and add it to the set if it belongs with it.
- Names that come in a family (`VAL_02_LOCKDOWN_BANK`, `_GUN`, `_HOTEL`, `_LAW`) are easiest to collect with a search for the shared part.
- Use **Toggle command** while you are testing, then switch to **Load** for the resource you ship.
## Limitations
- There is no picture of what an imap contains. You get its position, entity count and parent; checking what it looks like happens in game.
- The box covers the imap's entities only, rounded to the metre. An imap with a single prop has a box a metre or two wide and is easy to miss on the map until you click its spot.
- Imaps with no known name can only be found by clicking the map or by their hash.
- The site cannot check the result in game. Some imaps are meant to be loaded together or in place of another state, and the tool does not know those pairings.
## Related tools
- [Interiors](/redm/docs/tools/interiors)
- [Interactive Map](/redm/docs/tools/map)
- [Door Finder](/redm/docs/tools/door-finder)
- [Hash Calculator](/redm/docs/tools/hash-calculator)
- [RedM Assets](/redm/docs/tools/assets)
_Last updated: 2026-10-01_
---
## Train Tracks
URL: https://fivemad.com/redm/docs/tools/train-tracks
Every RDR2 railway, trolley, mine cart and riverboat track on the map, with its junctions, its config group, the trains it runs and Lua to spawn one.
Train Tracks draws every track in RDR2's `traintracks.xml` on the map: 28 of them, from the main railway loop to the Saint Denis trolleys, a mine cart line and the riverboat route. Click a track for its file, length, junctions and config group, then pick a train that runs on it to see its cars and copy the Lua that spawns it.
## What it is for
Spawning a train in RedM takes a train config hash and a point on a track, and neither is something you can guess. This tool shows you where the tracks really run, which tracks connect where, which trains the game lets run on the main line, and gives you the hash and the spawn call in one place.
## Quick start
1. Click a coloured line on the map, or pick a track in the **Tracks** list. The map zooms to fit it.
2. Read the details card under the list: file, nodes, length, whether trains stop at stations.
3. On the main line (`freight_group`), pick a train under **Trains this group runs**.
4. Check its cars, then copy the Lua or press **Config hash** to copy just the hash.
## The tracks
The list labels each track by what its config name says:
| Kind | Tracks | Examples |
| --- | --- | --- |
| Railway | 10 | `freight_group` (the main loop), `braithwaites2_track_config`, `trains_old_west01` |
| Trolley | 7 | `nb_trolley_track_config`, `trolley3`, `trolley_intersection2` |
| Junction link | 9 | `trains_intersection1_3`, `freight_nb1_inter` |
| Mine cart | 1 | `minecart_Jam3_4` |
| Riverboat | 1 | `riverboat_track_config` |
Together they run to about 46.6 km. The longest is the main loop in `trains1.dat`: 473 nodes, about 15.02 km, a closed loop. The riverboat route is 432 nodes and about 9.13 km, also closed.
On the map each track has its own colour. The selected one turns white and the others fade. Dots mark junction nodes: on the selected track always, and on every track once you zoom in.
## Track details
| Field | What it shows |
| --- | --- |
| **File** | The track file the nodes come from, for example `trains1.dat` |
| **Index** | Its position in `traintracks.xml`, counting from 0 |
| **Nodes** | Node count, the length in km, and whether it is a closed loop |
| **Stations** | Whether trains on it stop at stations |
| **Group hash** | The config group the track names, in hex and signed, or **not in trainconfigs.ymt** |
| **Junctions** | Every node the track file marks as a junction, with the name written on it (usually the track it joins, sometimes a station such as `Station_rho`). Click **node N** to fly to it. |
There are 132 junction nodes over all 28 tracks.
## Trains
A track names a config group, and a group lists the trains that may run on it. Only one group exists in the game's `trainconfigs.ymt`: `freight_group`, the one the main loop uses. Every other track shows **not in trainconfigs.ymt** and has no train list.
`freight_group` lists 39 trains. 8 of them have a known name (`engine_config`, `dummy_engine_config`, `handcart_config`, `minecart_config`, `trolley_config`, `winter4_config`, `prisoner_escort_config`, `appleseed_config`); the rest are listed by hash, which is what the native takes anyway. Each row shows how many cars the train has, from 1 to 18.
Click a train to see its cars in order and get the spawn code. For `engine_config` on the main loop:
```lua title="client.lua"
-- engine_config: 2 cars
local config = 845205129 -- 0x3260CE89
local models = {
-164452766, -- northsteamer01x
-544816550, -- northcoalcar01x
}
for _, m in ipairs(models) do
RequestModel(m)
while not HasModelLoaded(m) do Wait(0) end
end
-- _CREATE_MISSION_TRAIN (0xC239DBD9A57D2A71): config, x, y, z, direction, passengers, p6 (not documented), conductor
-- here: the first node of trains1.dat
local train = Citizen.InvokeNative(0xC239DBD9A57D2A71, config, 2493.4, -1482.2, 45.1, false, false, false, true)
```
The code loads every distinct car model first, then spawns the train at the first node of the selected track. Change the x, y, z to another node of the same track if you want it elsewhere; it has to be on the track.
**Config hash** copies the signed config hash on its own.
## Tips
- Use the junction list to find where a branch leaves the main line. Click **node N** and the map flies there.
- Trolley and junction link tracks are short pieces (some only 4 to 20 nodes) that join the bigger tracks. If a click picks the wrong line, zoom in further: the click takes the track with a node closest to the cursor, within 10 pixels.
- The car names in the list are model names, so you can look them up in [RedM Assets](/redm/docs/tools/assets) under **Vehicles**, where train cars and engines have their own groups.
## Limitations
- 3 of the 39 trains in `freight_group` have no matching entry in the game's train configs. They show as a hash with no car count, and clicking one shows nothing.
- 58 of the 70 train configs in the game have no known name. They are listed by hash.
- The length is measured flat (x and y only), so it is a little short on hills.
- The meaning of the native's last four arguments is only what the comment says; the code passes `false, false, false, true`. The site cannot test a spawn in game.
- Speed, stopping and driving the train are up to your own script.
## Related tools
- [Interactive Map](/redm/docs/tools/map)
- [Coords Picker](/redm/docs/tools/coords-picker)
- [RedM Assets](/redm/docs/tools/assets)
- [Hash Calculator](/redm/docs/tools/hash-calculator)
_Last updated: 2026-10-01_
---
## Interiors
URL: https://fivemad.com/redm/docs/tools/interiors
Every interior placed in the RDR2 world, on the map and as a list: rooms, portals, entity sets, the imap it needs, and Lua to switch its entity sets.
Interiors lists every interior (MLO) placed in the RDR2 world, 290 of them, as dots on the map and as a searchable list. Open one for its position, rooms, portals, entity sets and the imap that places it, set entity sets on or off, and copy the Lua that does it.
## What it is for
Shops, saloons, cabins and farmhouses in RDR2 change their contents through entity sets: a clean or ransacked farmhouse, an open or closed trapdoor, stock on the shelves. The natives that switch them want the interior handle and the set's exact name. This tool gives you both, plus the imap request for the interiors that do not exist until a script loads them.
## Quick start
1. Click a dot on the map, or search the list by interior, room or entity set name.
2. Read the card: position, heading, which imap places it, its rooms and its entity sets.
3. Set each entity set you want to change to **on** or **off**.
4. Copy the Lua under the list of sets.
## Finding an interior
| Control | What it does | Default |
| --- | --- | --- |
| **Interior, room or entity set** | Search box. Matches part of an interior name, part of a room or entity set name, or the interior's exact hash (8 hex digits, with or without `0x`). | empty |
| **Only interiors that need an imap loaded** | Keeps the 38 interiors whose imap only loads when a script asks. | off |
The line under the box counts what is shown, for example **14 of 290 placed interiors** for `val_`. Each row shows its room count and, when it has any, its entity set count.
On the map, orange dots are interiors that need their imap loaded and violet dots are always there. Zoom in and each interior also gets its outline: the footprint of its rooms, turned the way the interior stands. The open interior's outline is drawn in white at any zoom. Names appear next to the dots once you zoom in.
The open interior is kept in the address bar as `?id=`, so a link opens straight on it.
## The interior card
| Field | What it shows |
| --- | --- |
| **Hash** | The interior's hash, hex and signed |
| **Position** | x, y, z, with a **vector3** button that copies `vector3(x, y, z)` |
| **Heading** | The placement heading |
| **Placed by** | The imap that places it, by name or by hash, and whether that imap is **loaded by script** or **always loaded** |
| **Portals** | How many portals the interior has |
| **Rooms** | Every room name |
| **Entity sets** | Every set with a menu (**-**, **on**, **off**), its name and how many entities it holds |
**Its doors in the Door Finder** opens the [Door Finder](/redm/docs/tools/door-finder) searching for this interior.
## Entity sets and the code
Leave a set on **-** and the code does not touch it. **on** adds an activate call, **off** a deactivate call. With `ransacked_abe` on and `clean_abe` off at the Abe farmhouse:
```lua title="client.lua"
-- GET_INTERIOR_AT_COORDS (0xCDD36C9E5C469070): abe_farmhouse_int
local interior = Citizen.InvokeNative(0xCDD36C9E5C469070, 1786.83, -85.35, 55.94)
-- IS_VALID_INTERIOR (0x017C1B3159F79F6C)
if Citizen.InvokeNative(0x017C1B3159F79F6C, interior) then
-- ACTIVATE_INTERIOR_ENTITY_SET (0x174D0AAB11CED739)
Citizen.InvokeNative(0x174D0AAB11CED739, interior, "ransacked_abe", 0)
-- DEACTIVATE_INTERIOR_ENTITY_SET (0x33B81A2C07A51FFF)
Citizen.InvokeNative(0x33B81A2C07A51FFF, interior, "clean_abe", false)
end
```
When the interior's imap only loads on request, the code requests it first. For `adl_cabin01_int`, whose imap is known only by hash, the code starts with:
```lua title="client.lua"
-- the imap that places this interior only loads when a script asks
-- REQUEST_IPL_HASH (0x59767C5A7A9AE6DA): 0x9E6F346F
Citizen.InvokeNative(0x59767C5A7A9AE6DA, -1636879249)
```
These are client natives: put the code in a client script.
## Named and unnamed sets
The entity set natives take the set's **name**, and the game stores only its hash. Of the 846 entity sets across the 290 placed interiors, 395 have a known name. The other 451 show as `0x...` with **no name** in place of the menu, and they cannot be switched from a script until somebody finds their name.
Some interiors are almost fully covered (`val_saloon_int`, 7 of 7 named) and some not at all (`val_gunsmith_int_main`, 0 of 17). The biggest list is `val_genstore` with 66 sets, 18 of them named.
## Tips
- Set names often read as pairs: `clean_abe` and `ransacked_abe`, `adl_winter01_trapdoorclosed` and `adl_winter01_trapdooropen`. To swap one for the other, turn one on and the other off in the same snippet.
- The count next to a set is how many entities it holds. A set with 1 entity is a single prop; one with a few hundred is the whole dressing of the room.
- Search part of a room name such as `room_workshop` to find every interior that has one.
- Paste the **vector3** into your own script when you need the interior's position for a distance check.
## Common mistakes
- **Nothing switches.** The code only switches sets when `GET_INTERIOR_AT_COORDS` hands back a valid interior. If it does not (for example because the interior's imap was never requested), `IS_VALID_INTERIOR` fails and the code inside the `if` quietly does nothing. Keep the imap request at the top, and add a print in an `else` branch while testing.
- **Using a set from another interior.** Set names are per interior. A name from one interior does nothing in another.
## Limitations
- 451 of the 846 entity sets have no known name and cannot be switched.
- One interior is listed only by hash, and 32 are placed by an imap whose name is not known (it is shown and requested by hash).
- Some interiors are placed in more than one spot: the 290 rows are 279 different interiors. Each placement is its own row with its own position, so check the position before you copy.
- The site cannot check the result in game. The snippet switches the sets; whether the interior redraws straight away is not something the site has verified.
## Related tools
- [Imap Toggler](/redm/docs/tools/imap-toggler)
- [Door Finder](/redm/docs/tools/door-finder)
- [Interactive Map](/redm/docs/tools/map)
- [RedM Assets](/redm/docs/tools/assets)
_Last updated: 2026-10-01_
---
## Folders to YTD
URL: https://fivemad.com/redm/docs/tools/folders-to-ytd
Drop folders of images and get one RDR2 texture dictionary per folder, compressed and mipmapped in your browser, packed as a RedM resource.
Folders to YTD turns folders of images into RDR2 texture dictionaries. One folder in, one `.ytd` out, wrapped in a RedM resource with `game 'rdr3'` and a `stream/` folder. Everything happens in your browser tab: nothing is uploaded and there is nothing to install.
It is the same tool as the [FiveM Folders to YTD](/docs/tools/folders-to-ytd), writing RDR2 dictionaries instead of GTA V ones. The differences are listed under [What is different for RDR2](#what-is-different-for-rdr2).
## Quick start
1. Press **Choose a folder**, or drag folders onto the page. Every folder with images in it becomes its own `.ytd`. **Or pick single images** puts loose images into one dictionary called `textures`.
2. Check the names on each card: the **Dictionary name** at the top (that is the file name) and the texture name on every row.
3. Leave **Compression** on **Auto: BC3 with alpha, BC1 without** unless you know you want something else.
4. Leave **Colour textures in sRGB** on for model textures, and turn it off for UI sprites and icons.
5. Press **Build and download**. You get `.zip` with an `fxmanifest.lua`, a `README.md` and the `.ytd` files in `stream/`.
6. Unzip into `resources`, add `ensure ` to `server.cfg` and restart the whole server.
PNG, JPG, WebP, BMP and GIF are read. Anything else in the folder is listed as left out, and so is an image the browser cannot decode.
## The two names
| Name | Where it comes from | What uses it |
| --- | --- | --- |
| Dictionary | The folder the images sit in, and the `.ytd` file name | Whatever asks for the dictionary: a model's archetype, or your own script |
| Texture | Each image file name, without the extension | The model's shader, which asks for its texture by name |
> [!IMPORTANT]
> If a model wants `mywall_01` and your file is called `mywall01`, that material draws untextured, with no warning in game. The page tells you on the row whenever a texture name differs from its file name.
Both names are lower cased, and anything that is not a letter, a number, an underscore or a dash becomes an underscore. You can edit both on the page before you build.
The build is blocked, with the reason shown, when two textures in one dictionary have the same name or two folders would write the same `.ytd`.
## Output panel
| Option | What it does | Default |
| --- | --- | --- |
| **Compression** | The format for every texture. A row can override it with its own select. | Auto: BC3 with alpha, BC1 without |
| **Size** | **Resize to the nearest power of two**, or **Keep the original size**. | Resize to the nearest power of two |
| **Largest side** | Halves an image until its longest side fits: **No cap**, 512, 1024, 2048 or 4096 px. | 2048 px |
| **Build mipmaps** | The smaller copies the game draws at a distance, down to 4 px. | on |
| **High quality compression** | Slower, fewer block artefacts. Turn it off for a quick look. | on |
| **Set usage from the file name** | Treats `_n` names as normal maps and `_s` names as specular, everything else as colour. | on |
| **Colour textures in sRGB** | Stores colour textures in the sRGB form of their format, the way the game's own model textures are stored. | on |
Each row shows what the build will do with that image: size in and out, mip levels, usage and video memory, plus a note when it had to resize or rename something.
### Compression
| Format | Cost | Use it for |
| --- | --- | --- |
| BC1 (DXT1) | 0.5 byte per pixel | Solid textures, and cut outs where every pixel is fully on or fully off |
| BC3 (DXT5) | 1 byte per pixel | Anything with alpha that fades |
| BC5 (ATI2) | 1 byte per pixel | A two channel mask |
| BC4 (ATI1) | 0.5 byte per pixel | A single channel mask |
| B8G8R8A8 | 4 bytes per pixel | Gradients and UI art where block artefacts show |
**Auto** picks BC3 for any image with a pixel that is not fully opaque, and BC1 for the rest. BC7 is not offered, because the page cannot encode it; BC3 costs the same memory.
> [!WARNING]
> BC1 keeps only one bit of alpha. A pixel is solid or gone. That is fine for a leaf or a cut out sign and wrong for glass, smoke or a soft edge. The row warns you when it sees soft alpha going into BC1.
### sRGB
Leave it on for textures a model draws (walls, clothing, props). Turn it off for UI sprites and icons, which RDR2 keeps in plain (non sRGB) formats. Only colour textures are affected: normal maps, specular maps and masks are never stored as sRGB.
### Size and mipmaps
Mip levels only work on sizes that are powers of two, so the default resizes each side to the nearest one (172 becomes 128, 200 becomes 256). With **Keep the original size**, a texture that is not a power of two is written with a single level and the row warns you, because it will sparkle at a distance. RDR2's own textures that are not a power of two carry one level as well.
Turn **Build mipmaps** off only for something always drawn at one fixed size, like a UI sprite.
## Download panel
| Option | What it does | Default |
| --- | --- | --- |
| **Wrap it in a resource** | An `fxmanifest.lua` for `game 'rdr3'`, a README and a `stream/` folder. Off gives you the bare `.ytd` files in a zip. | on |
| **Resource name** | The folder and zip name. | `fivemad_textures` |
The panel also counts **Dictionaries**, **Textures** and **Video memory** before you build.
This is the manifest the default resource gets:
```lua title="fxmanifest.lua"
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
name 'fivemad_textures'
description 'RDR2 texture dictionaries built with https://fivemad.com/redm/tools/folders-to-ytd'
version '1.0.0'
-- Everything in stream/ goes to the streamer on its own. A .ytd does not need a
-- files {} entry and it does not need a data_file line. Add this resource to
-- server.cfg with ensure, then restart the whole server: streamed assets are
-- read once at startup, so a resource restart will not pick up a new one.
```
A `.ytd` in `stream/` needs no `files {}` entry and no `data_file` line. Streamed files are read when the server starts, so `restart myresource` will not pick up a new dictionary: restart the whole server, and if the old texture still shows, clear the server `cache` folder and your RedM client cache.
## What is different for RDR2
- The files are RDR2 dictionaries. A `.ytd` from the FiveM version of this tool will not work in RedM, and one from here will not work in FiveM.
- Formats are named the RDR2 way: BC1, BC3, BC4, BC5 and B8G8R8A8.
- The **Colour textures in sRGB** option exists only here.
- There is no "draw this from a script" snippet on the RedM page.
## Tips
- One folder per dictionary keeps names predictable. The dictionary is always the folder the image sits in directly, not a folder further up.
- When you are replacing textures of an existing model, copy the texture names from the model exactly. Fix them in the name boxes before you build.
- Watch the **Video memory** total. B8G8R8A8 is eight times the size of BC1.
## Limitations
- **Not tried in RedM yet.** The files were checked against Rockstar's own dictionaries and read back, but nobody at fivemad has loaded one in game. If a dictionary does not show up, tell us with your RedM build number.
- It does not open existing `.ytd` files and it cannot tell you which names a model wants. Those live in the model, not in your images.
- BC7 is not written.
- Large drops are read one image at a time in the browser, so hundreds of 4K images take a while and need the memory for it.
## Related tools
- [Blip Replacer](/redm/docs/tools/blip-replacer)
- [Map Editor](/redm/docs/tools/map-editor)
_Last updated: 2026-10-01_
---
## Blip Replacer
URL: https://fivemad.com/redm/docs/tools/blip-replacer
Swap RDR2 map blip icons for your own pictures and download a RedM resource with the rebuilt blip dictionaries, every stock icon carried over.
The Blip Replacer swaps RDR2's map blip icons for pictures of your own. Pick the blips, give each one a picture, and download a RedM resource that streams the rebuilt blip dictionaries. Everything runs in your browser tab; your pictures are not uploaded.
## What it is for
Changing what a blip looks like everywhere, for every script that uses it: a custom shop icon, a gang marker, a server logo on a stable. You do not touch any script. Every blip style that draws that icon picks up the new picture.
To place blips or choose a style instead, use the [Blip Placer](/redm/docs/tools/blip-placer) and [Blip Styles](/redm/docs/tools/blip-styles).
## Quick start
1. Find the icon in **Stock blips**. Search by texture name or label, or narrow it with the dictionary chips.
2. Click it. It moves into **Replacements** with an empty picture slot.
3. Click the dashed slot next to it and choose your picture.
4. Repeat for any other icons, then press **Build and download** in the **Download** panel.
5. Unzip `fivemad_blips.zip` into `resources`, add `ensure fivemad_blips` to `server.cfg` and restart the whole server.
You can also drop pictures named after a texture (`blip_shop_store.png`) anywhere on the page, or use **Pictures named after blips** to pick several at once. Each goes straight onto the blip of that name. A name that matches no blip texture is listed in an error under the page.
## The dictionaries
RDR2 keeps its blip icons in three texture dictionaries. The chips show how many icons each holds:
| Dictionary | Icons |
| --- | --- |
| `blips.ytd` | 321 |
| `blips_mp.ytd` | 308 |
| `blips_tu.ytd` | 1 |
That is 628 different icons. Two of them, `blip_direction_pointer` and `blip_radar_edge_pointer`, are in both `blips.ytd` and `blips_mp.ytd`; replacing one of those writes both files.
The grid holds every icon that matches the search and the dictionary chip, all 628 when both are empty. Scroll it, or type part of a name to narrow it down.
## Why the download holds every icon
A `.ytd` in a resource's `stream/` folder replaces the stock dictionary of the same name **as a whole**. It does not patch one texture into it. A `blips.ytd` holding only your icon would leave the other 320 blips with nothing to draw.
So the page writes the full dictionary for every dictionary you touched: your pictures where you replaced something and the stock icons everywhere else. The **Download** panel shows which **Files** will be written and how many **Textures written** that comes to.
## Your pictures
Each picture is fitted into the size of the icon it replaces, keeping its proportions. Most stock icons are 64 x 64; 41 are 256 x 256 and one is 36 x 36. The row under **Replacements** shows the size and the dictionary for each one.
Use a square PNG with a transparent background. A picture that is not square is centred with transparent space at the sides, and a solid background is drawn as a solid square on the map.
## Download panel
| Option | What it does | Default |
| --- | --- | --- |
| **Icons you did not replace** | **BC3, like the stock sizes**: one byte per pixel, the same memory as the game's own icons, edges of small icons can soften a little. **Uncompressed, exact pixels**: four bytes per pixel, every untouched icon keeps exactly the pixels the game draws. | BC3, like the stock sizes |
| **Use my own .ytd** | Drop your own copy of `blips.ytd` (or `blips_mp.ytd`, `blips_tu.ytd`) and the icons you did not replace are copied from it byte for byte. | not used |
| **Resource name** | Folder and zip name. | `fivemad_blips` |
Your replaced icons are always stored as BC3 or uncompressed, following the same choice.
### Using your own copy
Export the dictionary from your own RDR2 install with CodeX or a similar tool as a loose, unencrypted file, then press **Use my own .ytd**. The file name has to be one of the three dictionary names. After reading it the page tells you how many textures it found and whether any stock icon is missing (a missing one is filled from fivemad's pictures). **Forget the dropped files** goes back to the default.
## What is in the zip
```
fivemad_blips/
fxmanifest.lua
README.md
stream/blips.ytd
```
with one `.ytd` for each dictionary you touched. The manifest:
```lua title="fxmanifest.lua"
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
name 'fivemad_blips'
description 'RDR2 blip icons replaced with https://fivemad.com/redm/tools/blip-replacer'
version '1.0.0'
-- Nothing to list here. Every .ytd in stream/ is handed to the streamer on its
-- own and replaces the stock dictionary of the same name.
```
Streamed files are read when the server starts, so restart the whole server, not just the resource. If you still see the old icon, clear the server `cache` folder and your RedM client cache.
## Checking it in game
Once a replacement has a picture, a **Checking it in game** block appears under the page. It adds a `/blipcheck` command that puts a blip with your first replaced icon 20 m north of you. For `blip_shop_store`:
```lua title="client.lua"
-- Test for blip_shop_store: /blipcheck puts a blip 20 m north of you with that icon.
RegisterCommand('blipcheck', function()
local p = GetEntityCoords(PlayerPedId())
-- BLIP_ADD_FOR_COORDS (0x554D9D53F696D002) with BLIP_STYLE_PICKUP_WEAPON (1664425300)
local blip = Citizen.InvokeNative(0x554D9D53F696D002, 1664425300, p.x, p.y + 20.0, p.z)
-- SET_BLIP_SPRITE (0x74F74D3207ED525C): blip_shop_store
Citizen.InvokeNative(0x74F74D3207ED525C, blip, 1475879922, true)
-- _SET_BLIP_NAME (0x9CB1A1623062F402)
Citizen.InvokeNative(0x9CB1A1623062F402, blip, 'blipcheck')
end, false)
```
The same command is in the README inside the zip, with the steps of the smallest test: replace one blip, build, install, join, run `/blipcheck`.
## Tips
- Test with a single replaced blip first. If that one shows, add the rest.
- Keep icons simple and high contrast. They are drawn small on the map and the minimap.
- Do not run two resources that both stream `blips.ytd`. Only one copy of a dictionary can be in use, so one set of icons is lost. Put all your blip changes in one build.
## Limitations
- **Not tried in RedM yet.** The files follow the layout of the game's own dictionaries and read back cleanly, but nobody at fivemad has loaded one in game. If blips go missing or the map crashes, remove the resource and tell us your RedM build number.
- The game ships the blip dictionaries twice, an HD copy and a standard copy. These files are the HD sizes (64 x 64, 256 x 256 for the 41 mission area icons, 36 x 36 for one); the standard copy is mostly half that. Which copy a streamed file replaces on each texture quality setting is not known yet, so an icon that only shows on one setting is probably that.
- Your own `.ytd` has to be loose and unencrypted. A file still packed or encrypted cannot be read.
## Related tools
- [Blip Styles](/redm/docs/tools/blip-styles)
- [Blip Placer](/redm/docs/tools/blip-placer)
- [Folders to YTD](/redm/docs/tools/folders-to-ytd)
- [Map Editor](/redm/docs/tools/map-editor)
_Last updated: 2026-10-01_
---
## Map Editor
URL: https://fivemad.com/redm/docs/tools/map-editor
Draw roads, railways, borders, buildings, water, labels and pictures on RDR2's in-game map, mainland or Guarma, and download the rebuilt map tiles as a RedM resource.
The Map Editor lets you draw on RDR2's own pause map and minimap: new roads and tracks, a railway, a state border, buildings, a lake, a place name, your server's logo, or erase what is there. It rebuilds the game's map tiles with your edits in them and downloads them as a RedM resource. Everything runs in your browser tab.
## What it is for
Showing players the world your server actually has: a new town needs its streets and its name on the map, a closed road should vanish from it, a custom area can be marked with a border or a logo. The game draws its map from tiles, so changing those tiles changes the map for everyone who runs the resource, with no script at all.
## Before you start: your own tiles
The page does not ship Rockstar's map tiles. You bring them from your own game:
1. Open `minimap_tiles.rpf` from your RDR2 install with OpenIV, CodeX or a similar tool.
2. Export its `.ytd` files as loose files, **not Oodle compressed**, into a folder.
3. In the **Your stock tiles** panel press **Pick a folder** (or **Pick files**) and choose them.
You only need the tiles your edits touch; the **Download** panel names them. You can start drawing before you load anything: until then the page draws your edits over fivemad's own map so you can place them, but it cannot export.
Your tiles stay in the tab and are never saved, so load them again on each visit.
## Quick start
1. Pick **Mainland** or **Guarma** with the switch on the map.
2. Choose a tool in the toolbar (**Ink**, **Buildings**, **Label**, **Picture**, **Erase**) and draw.
3. Load your stock tiles (see above). The preview switches to **Your tiles** so you see the real tiles with your edits in them.
4. In **Download**, check that every changed tile has a pixel count and none says "not loaded".
5. Press **Build and download**, unzip `fivemad_map.zip` into `resources`, add `ensure fivemad_map` to `server.cfg` and restart the whole server.
Drag to pan and scroll to zoom.
## The toolbar
| Tool | Key | What it does |
| --- | --- | --- |
| **Select and move** | V | Click a shape to select it, drag it or drag one of its points. Delete or Backspace removes it. |
| **Ink** | P | Lines: roads, tracks, railways, borders, coast, relief lines, rivers. |
| **Buildings and water** | A | Filled shapes: buildings or water. |
| **Label** | T | A place name. |
| **Picture** | S | Stamps an image onto the map. |
| **Erase** | E | Removes existing map ink, or water, under a brush. |
| **Ruler** | M | Drag to measure a distance in metres. Esc clears it. |
Also in the toolbar: **Undo** (Ctrl+Z) and **Redo** (Ctrl+Y or Ctrl+Shift+Z), the **Grid** overlay (its step follows the zoom and is printed in the corner), snapping to the **Grid**, snapping to **Points** of other shapes (on by default), and the preview switch **Edits over map** / **Your tiles**.
### Ink
Pick a style from the chips, click to add points, then click the last point again or press Enter to finish. Esc drops the line you are drawing.
| Style | Goes on the layer | Default half width |
| --- | --- | --- |
| **Road** | Roads and coast | 2.57 m |
| **Small road** | Roads and coast | 1.27 m |
| **Dirt track** | Roads and coast | 0.25 m |
| **Railway** | Roads and coast, dashed 14 m on, 8 m off | 1.27 m |
| **Border** | Labels and borders, dash dot like the stock state borders | 1.27 m |
| **Coastline** | Roads and coast | 0.76 m |
| **Relief line** | Relief | 9.09 m |
| **River** | Water, a ribbon of water | 6 m |
The road widths are matched to the line weights the stock map already uses, so a new road looks like its neighbours. Select a line to change its **Style**, its **Half width** (up to 20 m, 200 m for a river) or make it a **Closed loop**.
### Buildings and water
Pick **Building** (drawn on Roads and coast) or **Water** (drawn on the Water layer), then **Rectangle** (click two corners, the default) or **Polygon** (click the corners, click the first one to close). Selecting an area lets you switch its **Kind**.
### Label
Click where the label goes; it is created as "New label" and selected so you can edit it on the right.
| Option | What it does | Default |
| --- | --- | --- |
| **Text** | Up to 120 characters. | New label |
| **Font** | **Serif (your system's)**, **Sans (Geist)**, or a font you add with **Use my own .ttf or .otf**. | Serif |
| **Bold** | Bold weight. | off |
| **Size** | Letter size in world metres, 5 to 400. | 45 m |
| **Rotation** | Degrees, -180 to 180. | 0 |
| **Bend (arc radius, 0 is straight)** | Curves the text along an arc; negative bends the other way. | 0 |
| **Letter spacing** | Extra space between letters, in metres. | 2 m |
Labels go on the **Labels and borders** layer.
### Picture
Press **Add a picture** (PNG, WebP or JPEG), choose the layer it should land on (Roads and coast by default), then click the map to place it. Selected, it has **Width** (5 to 3000 m, the height follows the picture), **Rotation** and **Ink comes from**: **The picture's transparency** (default, for a PNG with a transparent background) or **Its dark pixels** (for a dark drawing on white).
### Erase
Choose the layer to erase from and the **Brush** size (2 to 300 m, default 20 m), then drag over what should go. The stock ink under the brush is removed and a road you cut ends cleanly at the brush. Erasing on the Water layer turns water into land. An erase stroke is a shape like any other: select it to change its radius, hide it or delete it to bring the ink back.
## The layers
RDR2's map is several sets of tiles, one per kind of content. The **Your stock tiles** panel lists them with how many of each you have loaded, and the eye button hides one in the preview.
Mainland:
| Layer | Tile names | Grid (rows x columns) |
| --- | --- | --- |
| Roads and coast | `minimap_sdf_discovered3_` | 29 x 33 |
| Relief | `minimap_sdf_undiscovered3_` | 29 x 33 |
| Labels and borders | `minimap_sdf_text_` | 8 x 10 |
| Water | `minimap_sdf_waterline_` | 8 x 8 |
| Roads, zoomed out | `minimap_sdf_discoveredlod3_` | 5 x 5 |
| Labels, zoomed out | `minimap_sdf_textlod3_` | 5 x 5 |
Guarma:
| Layer | Tile names | Grid (rows x columns) |
| --- | --- | --- |
| Roads and coast | `minimap_guarma_sdf_discovered2_` | 24 x 16 |
| Relief | `minimap_guarma_sdf_undiscovered2_` | 24 x 16 |
| Labels | `minimap_guarma_sdf_text_` | 6 x 4 |
| Water | `minimap_guarma_sdf_waterline_` | 8 x 4 |
**Relief** holds the contour lines and hatching shown in parts of the map you have not discovered yet. A tile is named row first: `minimap_sdf_discovered3_17_15` is row 17, column 15.
Every selected shape has a **Written to** select, so you can move any shape to another layer, for example a picture onto Relief.
## The preview
- **Edits over map** draws fivemad's own RDR2 map with your changes on top: new ink in the map's ink colour, removed ink in red.
- **Your tiles** draws the stock tiles you loaded with your edits merged in.
Neither is exactly what the game draws. The tiles hold line shapes, not colours, and the game inks them with its own map shader, so line weights and colours in game will differ a little from the page.
## Download panel
| Option | What it does | Default |
| --- | --- | --- |
| **Also write the zoomed out sets** | Mainland only. Roads also go to the zoomed out roads set and labels to the zoomed out labels set, so the edit shows at every zoom. | on |
| **Resource name** | Folder and zip name. | `fivemad_map` |
Under it is the list of changed tiles with the number of pixels each edit changed. A tile you have not loaded is marked **not loaded** in amber, and **Build and download** stays off until you load it: the export merges your edits into your own copy of each tile, so it cannot write one it has not read. It also waits while tiles are still being rebuilt.
The download holds only the region you have open. Shapes keep their world positions when you switch region, but a mainland edit never reaches Guarma's tiles, so make one resource per region.
### What is in the zip
```
fivemad_map/
fxmanifest.lua
README.md
map-editor-project.fmmap
stream/
```
Each `.ytd` is named after the stock tile it replaces. A tile the game ships as an empty 4 x 4 stand in (nothing drawn there) is written at the full tile size so your edit has room, and the result line tells you how many there were. The manifest for a mainland map:
```lua title="fxmanifest.lua"
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
name 'fivemad_map'
description 'RDR2 map edits (Mainland) built with https://fivemad.com/redm/tools/map-editor'
version '1.0.0'
-- Everything in stream/ is picked up by itself: a .ytd named like a stock map tile
-- replaces that tile. Nothing to script and nothing to list here.
```
Streamed files are read when the server starts, so `restart fivemad_map` is not enough: restart the whole server, and if the old map still shows, stop it, delete its `cache` folder and start it again.
## Save and share
| Action | What it does |
| --- | --- |
| **Name** | The map's name, used for saves and the `.fmmap` file. Default "My map". |
| **Save in this browser** | Adds a named save to the list below, with its pictures and fonts. |
| **.fmmap file** | Downloads the whole project, pictures and fonts included. |
| **Open .fmmap** | Opens one. |
| **Copy share link** | Copies a link that opens this map. Pictures are left out of links and a font you added falls back to serif; a map too big for a link asks you to send the `.fmmap` file instead. |
The open map is also saved automatically in your browser and comes back when you return. The zip carries `map-editor-project.fmmap` too, so you can always reopen a map you exported.
## Tips
- Load the whole folder of tiles, not just the ones you think you need. An erase next to a tile you have not loaded cannot take that tile's ink into account, and the page says so under the map.
- Turn on **Points** snapping (it is on by default) to join a new road to the end of another one cleanly.
- Use the **Ruler** to size a building or a label against the stock map before you commit to it.
- Keep a map's edits in one resource. Two resources that stream the same tile names cannot both be in use, so one of them loses its edits in those tiles.
## Limitations
- **Not tried in RedM yet.** The tiles follow the layout of the game's own files and an unchanged tile comes out identical to the stock one, but nobody at fivemad has loaded one in game. The [Blip Replacer](/redm/docs/tools/blip-replacer) ships the smallest test for every RDR2 texture the site writes; until that has been run, treat this resource as untested.
- Whether the game draws a tile that was a 4 x 4 stand in at its new full size is not known.
- Where the zoomed out roads set sits is taken from the zoomed out labels set, which has the same size. It was not checked against coordinates on its own.
- The preview colours are fivemad's, not the game's map shader.
- Your stock tiles are needed to export and are not kept between visits.
- Only the open region is exported.
## Related tools
- [Interactive Map](/redm/docs/tools/map)
- [Blip Replacer](/redm/docs/tools/blip-replacer)
- [Blip Placer](/redm/docs/tools/blip-placer)
- [Folders to YTD](/redm/docs/tools/folders-to-ytd)
_Last updated: 2026-10-01_
---
## RedM Files
URL: https://fivemad.com/redm/docs/tools/files
Keep RDR2 and RedM files in your browser. Each file is identified from its bytes, its contents are read, and it points you at the RedM tool that opens it.
RedM Files is a workspace for RDR2 and RedM files that lives in your browser. Drop files or a whole resource folder and each file is identified from its bytes, not its name: a texture dictionary shows its textures, a model its LODs and collision, a map file its entities, a manifest whether RedM will start it. Then it points you at the RedM tool that takes it. Nothing is uploaded.
## What it is for
- Finding out what a file really is when the name is no help, or when the name is wrong.
- Checking a resource before you put it on a server: is that `.ytd` encrypted, does the manifest have the `rdr3_warning` line, is that `.ymap` replacing a stock one.
- Keeping the files you are working on in one place, with older versions kept when you drop a new copy.
## Quick start
1. Open the page. A new workspace has a **RedM** folder with **resources** inside it, and opens on **resources**.
2. Drag files or folders onto the page, or use **Add files** or **Add a folder**. A dropped folder keeps its structure, up to 8 levels deep.
3. Click a file. The panel shows what it was read as, what is inside, and where it can go next.
4. Use **Open it in** to jump to a tool. Browsers do not let one page hand a file to another, so drop the file again there (**Save a copy** gives you a copy to drop).
## The workspace
| Control | What it does |
| --- | --- |
| **Add files** / **Add a folder** | Add to the open folder. Dragging onto the page does the same. |
| **New folder** | Makes a folder and puts its name straight into rename. |
| Folder rail (wide screens) | The whole tree. Drop a file or row on a folder there to put it in that folder. |
| Row buttons | Save the file, move it to another folder, rename it, delete it. |
| **This browser** | How much of the workspace budget is used, and what the browser reports it has room for. |
| **Ask to keep it** | Asks the browser not to clear the workspace on its own when the disk fills. Shown only while it has not agreed. |
| **Delete everything** | Empties the workspace back to the starting folders, after a confirm. |
The **RedM** and **resources** folders are fixed: they cannot be renamed, moved or deleted.
Limits: up to 256 MB per file and a 1 GB budget for the whole workspace. The browser sets its own quota as well, which the **This browser** box shows next to ours.
## Versions
Adding a file whose name is already in the folder makes a new version instead of overwriting it. The **History** card of a file lists every version kept, with its size and date:
- the first copy and the nine newest after it are kept (ten in all), and the page tells you when an old one drops out;
- **Make version N current** only changes which one is current, nothing is deleted;
- each version can be saved or deleted on its own. The current one cannot be deleted from there.
## How a file is identified
The first bytes decide, the name is only a hint. An RDR2 resource starts with `RSC8` and carries a resource id, and the id says which family it is: texture dictionary, model, fragment, map file, clip dictionary and so on.
When the name and the bytes disagree, the file gets a **not a .xxx** badge and the panel says **The name and the bytes disagree** with what the bytes really are. When the page cannot read a file at all, it gets a **locked** badge and says why under **Nothing here can open this**.
| What you drop | What happens |
| --- | --- |
| A loose, unencrypted RSC8 file (no compression or Deflate) | Read in full |
| An encrypted RSC8 file | Locked. It is still the copy from inside the game's archives. |
| An Oodle compressed RSC8 file | Locked. Export it again with no compression or with Deflate. |
| An RDR2 archive (RPF8) | Locked. Its entry count and whether its table of contents is encrypted are shown, nothing more. |
| A GTA V file (RSC7) or archive (RPF7) | Locked here, with a link to the FiveM [Files](/files) page, which reads them |
| A CodeX or Sollumz XML export | Read as XML, with a note that it has to go back to the binary file before RedM streams it |
| A Cfx escrow protected file | Locked. It can be streamed as it is and nothing else. |
## What is inside
The **What is inside** card depends on the file:
| File | What it shows |
| --- | --- |
| `.ytd` | Texture count, formats, biggest size, a table of every texture (size, format, mips, bytes) and pictures of the first 8 |
| `.ydr` `.ydd` `.yft` | LODs with vertices, triangles and swap distance, size in metres, whether it is skinned, shaders, embedded textures and the textures it asks for, collision. A fragment also lists its physics. |
| `.ybn` | The collision bounds and their size |
| `.ymap` | Name hash, parent, flags (including "script only"), entity count, instanced props, entity extents, and a table of the archetypes it places |
| `.ytyp` | Archetype count, how many interiors it defines with their total rooms and entity sets, and a table of every archetype (kind, LOD distance, size, whether a stock model has that name) |
| `fxmanifest.lua` | `fx_version`, the game line, and whether `rdr3_warning` is there word for word |
| RDR2 photo mode file | The picture, plus title, size, when it was taken, in-game time and where |
| `.zip` | Every file inside, biggest first, and how many `fxmanifest.lua` it holds |
| `.dds` | The picture, its size, format and mip levels |
| Pictures, audio, video | Shown or played |
| Text files | The text |
Tables show up to 400 rows.
For a `.ytd`, `.ydr`, `.ydd` or `.yft`, the page also says whether RDR2 ships a file of that name, because a streamed file with a stock name replaces the game's own. Most stock files are stored under a hash only, so "not among the names known from the game" does not prove a name is new. A `.ymap` whose name hash matches a stock imap says so, with whether that imap loads with the world or only on request and how many entities the game's copy has.
## Where a file goes next
**Open it in** lists the tools that take the file as it is. **Works on this kind of thing** lists tools that are about the same kind of file but cannot open yours.
| File | Open it in | Works on this kind of thing |
| --- | --- | --- |
| `blips.ytd`, `blips_mp.ytd`, `blips_tu.ytd` | [Blip Replacer](/redm/docs/tools/blip-replacer) | Blip Styles, Folders to YTD, Resource Conflict Checker |
| An in-game map tile `.ytd` (`minimap_sdf_...`) | [Map Editor](/redm/docs/tools/map-editor) | Folders to YTD, Resource Conflict Checker |
| Any other `.ytd` | | Folders to YTD, Resource Conflict Checker |
| A picture | Folders to YTD, Blip Replacer, Map Editor, Loading Screen Generator | |
| A video (WebM, MP4) or music (MP3, OGG, WAV) | Loading Screen Generator | |
| An RDR2 photo mode file | [Photo Mode Converter](/redm/docs/tools/photo-converter) | |
| A font, or a `.fmmap` project | Map Editor | |
| A `.zip` | [Resource Conflict Checker](/redm/docs/tools/resource-conflicts) | |
| `.ymap` | | [Imap Toggler](/redm/docs/tools/imap-toggler), Resource Conflict Checker |
| `.ytyp` | | [Interiors](/redm/docs/tools/interiors), Resource Conflict Checker |
| `.ydr` `.ydd` `.yft` `.ybn` `.yld` `.ymt` `.ynv` `.ycd` `.ypt` | | Resource Conflict Checker |
| `.yldb` | | [Game Text Search](/redm/docs/tools/text-search) |
| `fxmanifest.lua` | | Resource Conflict Checker (drop the whole folder there) |
| `server.cfg` | | [server.cfg Generator](/redm/docs/tools/server-cfg-generator) (it builds one, it does not import yours) |
| A GTA V file | [Files](/files) on the FiveM side | |
A locked file gets no tool, except a GTA V file, which is sent to the FiveM side.
When the open folder looks like a resource, a card **Open this folder in** appears above the list: a folder with an `fxmanifest.lua` goes to the Resource Conflict Checker, a folder of map tiles to the Map Editor, a folder of pictures to Folders to YTD, a folder of photo mode files to the Photo Mode Converter.
## The manifest check
Dropping an `fxmanifest.lua` lists anything that stops RedM from starting it. A manifest that passes looks like this:
```lua title="fxmanifest.lua"
fx_version 'cerulean'
game 'rdr3'
rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'
```
What it flags:
- no `fx_version`, or one that is not `adamant`, `bodacious` or `cerulean`;
- no `game` line, or a game list without `rdr3` (or `common`);
- a `game 'rdr3'` resource with no `rdr3_warning` line, or one whose text is not word for word, asterisks around *will* included.
This is a quick look at the lines that decide whether the resource starts. The [Resource Conflict Checker](/redm/docs/tools/resource-conflicts) reads the whole resource with its files.
## Common mistakes
- **Dropping files straight out of the game's archives.** Those are encrypted and Oodle compressed, and a browser has neither the key nor the decompressor. Export them with CodeX on your own machine, unencrypted, with no compression or Deflate, and drop that.
- **Trusting the extension.** A `.ydr` that is really a `.ydd`, or a `.ytd` saved without its header, is flagged. Fix the file, not the page.
- **Expecting the files on another browser or computer.** They live in this browser only.
## Limitations
These are the limits the page itself states:
- **Where do the files go?** Into this browser's own storage on this machine, and nowhere else. No account, no server, no upload. The RedM workspace is kept apart from the FiveM one. Clearing site data for fivemad.com, or opening the page in a private window, means an empty workspace.
- **How is a file identified?** By its first bytes, then by its name. If the name and the bytes disagree, the page says so instead of trusting the name.
- **What it will not do.** It does not read your disk or your RDR2 install, and it cannot open an encrypted or Oodle compressed file, or look inside an RPF8 archive.
- **Versions and backups.** The first copy and the nine newest after it are kept, and restoring an older one only changes which is current.
On top of that: the page reads files, it does not change them. Some resource types (for example `.ypm`, `.yad`, `.ywr`) are recognised but only their container is read, and the panel says so rather than guessing at their contents.
## Related tools
- [Resource Conflict Checker](/redm/docs/tools/resource-conflicts)
- [Folders to YTD](/redm/docs/tools/folders-to-ytd)
- [Blip Replacer](/redm/docs/tools/blip-replacer)
- [Map Editor](/redm/docs/tools/map-editor)
- [RedM Assets](/redm/docs/tools/assets)
_Last updated: 2026-10-01_
---
## RedM Assets
URL: https://fivemad.com/redm/docs/tools/assets
Browse RDR2's blips, peds, horses, weapons, vehicles, items, documents, scenarios, controls, timecycles, weathers, zones, interiors, imaps and scripts with hashes and Lua.
RedM Assets lists the names and hashes a RedM script needs, read from RDR2's own game files (build 1.0.1491.50). Pick a type, search by name, label or hash, and open a row for its hash in three forms and a line of Lua that uses it. Labels are the game's own English text. A name nobody could recover is shown as its hash, never guessed.
## What it is for
Looking up the model name of a horse breed, the hash of an input, the scenario a ped plays at a campfire or the dictionary a blip icon lives in, without digging through dumps. Every row gives you the hash as hex, unsigned and signed, so it matches whatever form your script or framework config uses.
## Quick start
1. Pick a type from the chips at the top. The page opens on **Blips**.
2. Type in **Search ... by name, label or hash**.
3. Narrow it with the group chips under the search box, or leave it on **All**.
4. Click a row. The panel on the right shows **Hash**, **Unsigned** and **Signed** with a copy button each, the facts for that type and a `client.lua` block with **Copy**.
The view is kept in the address bar (`?t=peds&q=bear&g=Animals&id=...`), so you can link straight to a row.
## The types
The number on each chip is the row count of that type's data file. Rows with a picture are listed first.
| Type | Rows | Grouped by | Pictures |
| --- | --- | --- | --- |
| **Blips** | 628 | Dictionary: `blips` 321, `blips_mp` 306, `blips_tu` 1 | all 628 |
| **Peds** | 1,983 | Category, 19 groups (Multiplayer 611, Cutscene 331, Unique 232, Horses 144, Ambient male 132, Animals 119...) | none |
| **Horses** | 144 | Breed, 26 groups (Gang and story horses 22, Mustang 8, Arabian 7...) | none |
| **Weapons** | 142 | Kind: Hand held 107, Animal attacks 18, Damage types 13, Mounted 4 | 60 |
| **Vehicles** | 115 | Type: Wagons and carts 56, Train cars 27, Boats 11, Train engines 6, Canoes 4, Rowing boats 4, Artillery and gatling guns 3, Hand and mine carts 2, Mounted guns 1, Balloon 1 | none |
| **Items** | 18,550 | Category, 17 groups (Clothing 10,494, Name not known 5,465, Component 663, Horse 418, Provision 362...) | 765 |
| **Documents** | 378 | Kind, 11 groups (Letter 115, Pamphlet 98, Note 69, Document 31, Bounty 23, Treasure map 13...) | all 378 |
| **Scenarios** | 2,666 | File, 33 groups | none |
| **Controls** | 373 | Pad: Has a pad default 235, No pad default 138 | none |
| **Timecycles** | 1,286 | File: `timecycle_mods_1.xml` 729, `_3` 376, `_2` 139, `_4` 42 | none |
| **Weathers** | 22 | Mode: Everywhere 21, Single player only 1 | none |
| **Zones** | 87 | Type: Town 24, District 19, Lake 11, State 9, River 9, Creek 7, Pond 6, Swamp 1, Ocean 1 | none |
| **Interiors** | 290 | Load mode: Always there 252, Needs its imap loaded 38 | none |
| **Imaps** | 7,516 | Load mode: Loads with the map 4,877, Loads when a script asks 2,639 | none |
| **Scripts** | 2,195 | Set: Story (script_rel) 1,639, Online (script_mp_rel) 556 | none |
**Horses** are the same rows as the **Horses** group of **Peds**, split by breed: in RDR2 a horse is a ped model.
## Searching
| You type | It matches |
| --- | --- |
| Words, `bear` | Any row whose name or label contains it |
| A decimal number, `-640622144` or `3654345152` | The row with that hash, signed or unsigned |
| A hex hash of 6 to 8 digits, `0xD9D0E1C0` or `d9d0e1c0` | The row with that hash |
The search runs inside the open type only. The list shows 120 rows at first; **Show more** adds more and says how many are left.
## What each row gives you
Every row has **Hash** (hex), **Unsigned** and **Signed**. The facts and the Lua line depend on the type:
| Type | Facts | The Lua line |
| --- | --- | --- |
| Blips | Dictionary, size, the blip styles that use it | Adds a blip with the first style that uses the icon (or `BLIP_STYLE_PICKUP_WEAPON`, a plain white style, for the 540 icons no style uses) and sets the sprite |
| Peds, Horses | Outfits, town sets, where the name came from | Loads the model, `CreatePed`, then a random outfit |
| Weapons | Group, slot, ammo | The weapon hash |
| Vehicles | Type, handling, layout, base game or DLC pack | Loads the model and `CreateVehicle`; a train car only gets its hash, with a note that it runs as part of a train config |
| Items | Catalog (story mode, Online), shops, where the name came from | The item hash |
| Documents | Dictionary, size, base or update copy | Requests the texture dictionary the page is drawn from. The picture is shown full width. |
| Scenarios | The scenario's type | Starts it in place on `ped` |
| Controls | Pad inputs | An `IsControlJustPressed` check on its hash |
| Timecycles | Parameter count | `SetTimecycleModifier` |
| Weathers | Short name, timecycle file | The weather hash |
| Zones | Type, box, polygon count | The zone hash |
| Interiors | Position, rooms, portals, entity sets, imap | Requests the imap when it only loads on request, then `GetInteriorAtCoords` |
| Imaps | Entities, area, parent | One line to load it and one to remove it |
| Scripts | Code size, natives called, statics, file size | The script hash |
When a name is known, the Lua writes `joaat("name")`; when only the hash is known, it writes the hex hash. Some natives are called by hash with `Citizen.InvokeNative`, with the native's name in a comment.
For a horse, `a_c_horse_arabian_white`:
```lua title="client.lua"
local model = joaat("a_c_horse_arabian_white")
RequestModel(model)
while not HasModelLoaded(model) do Wait(0) end
local ped = CreatePed(model, x, y, z, heading, true, false, false, false)
-- _SET_RANDOM_OUTFIT_VARIATION: a RedM ped with no outfit is invisible
Citizen.InvokeNative(0x283978A15512B2FE, ped, true)
SetModelAsNoLongerNeeded(model)
```
For a control, `INPUT_JUMP`:
```lua title="client.lua"
if IsControlJustPressed(0, 0xD9D0E1C0) then -- INPUT_JUMP
end
```
`x`, `y`, `z`, `heading` and `ped` are yours to fill in.
**Zones**, **Interiors** and **Imaps** also get an **Open in** button for the tool that shows them on the map: the [Coords Picker](/redm/docs/tools/coords-picker), [Interiors](/redm/docs/tools/interiors) and the [Imap Toggler](/redm/docs/tools/imap-toggler).
## Tips
- Keep the outfit line of the ped snippet. As its comment says, a RedM ped with no outfit is invisible.
- Use **Horses** rather than **Peds** when you want a breed: the breed chips sort the 144 horse models for you.
- A control in RedM is the joaat hash of its `INPUT_` name. Search the plain word (`jump`, `sprint`): it matches the `INPUT_` name as well as the label.
- **Name from** on peds and items says where a name came from: the game's own file or icon name, or an exact hash match against a name list. Either way the name hashes to the row's hash.
## Limitations
- Names: 5 weapons, 1 ped, 1 interior, 2,392 imaps and 5,465 items (exactly the **Name not known** group) are known only by hash. They still work in a script, since the natives take the hash.
- Labels exist only where the game has English text for the thing: 182 of 628 blips, 109 of 142 weapons, 14,464 of 18,550 items, 112 of 378 documents, 38 of 373 controls and 73 of 87 zones. Peds, horses and vehicles have none.
- Pictures exist for blips, documents, 60 weapons and 765 items. Everything else is a text row.
- The Lua is a starting line, not a finished script. The site cannot check it in game.
## Related tools
- [Hash Calculator](/redm/docs/tools/hash-calculator)
- [Item Generator](/redm/docs/tools/item-generator)
- [Blip Placer](/redm/docs/tools/blip-placer)
- [Blip Styles](/redm/docs/tools/blip-styles)
- [Imap Toggler](/redm/docs/tools/imap-toggler)
- [Interiors](/redm/docs/tools/interiors)
- [RedM Files](/redm/docs/tools/files)
_Last updated: 2026-10-01_
---
# Tool list
Every tool runs in the browser and is free.
- server.cfg Generator (https://fivemad.com/redm/tools/server-cfg-generator): A RedM server.cfg with set gamename rdr3, the enforced build, and presets copied from the default, VORP and RSG txAdmin recipes.
- Prompt Builder (https://fivemad.com/redm/tools/prompt-builder): Build a group of RDR2 prompts (press, hold or mash) on the game's own controls and hold timings, preview it, and copy the Lua.
- Loading Screen Generator (https://fivemad.com/redm/tools/loading-screen): A RedM loadscreen resource: background image or video, music, a real progress bar and log lines, downloaded as a zip.
- Photo Mode Converter (https://fivemad.com/redm/tools/photo-converter): Turn RDR2 photo mode files (PRDR) into JPEG pictures in your browser. Nothing is uploaded.
- Resource Conflict Checker (https://fivemad.com/redm/tools/resource-conflicts): Drop several RedM resources and see duplicate stream files, overrides of stock RDR2 files, repeated data_file lines and manifest mistakes.
- Item Generator (https://fivemad.com/redm/tools/item-generator): Pick RDR2 items with their game icons and get the VORP items SQL or the RSG shared items Lua.
- Hash Calculator (https://fivemad.com/redm/tools/hash-calculator): joaat hashes for RDR2 names, one or a whole list at once, and a reverse lookup against the names and game text read from RDR2's own files.
- Game Text Search (https://fivemad.com/redm/tools/text-search): Search all 259,297 lines of RDR2's English text by words, label hash or key, with the Lua to replace a line in RedM.
- Interactive Map (https://fivemad.com/redm/tools/map): The RDR2 map drawn from the game's own files: terrain or paper style, a 3D view with the towns' buildings, and the world position under the cursor.
- Coords Picker (https://fivemad.com/redm/tools/coords-picker): Click the RDR2 map for x, y, z and a heading, copy them as vector3, vector4 or JSON, and see the state, district, town and water there.
- Blip Placer (https://fivemad.com/redm/tools/blip-placer): Place blips on the RDR2 map with the game's own blip icons and styles, then copy the Lua or a VORP or RSG config block.
- Blip Styles (https://fivemad.com/redm/tools/blip-styles): All 620 blip styles of RDR2's blipdata.ymt: the icon each one draws, the styles it inherits from, and a line of Lua to use it.
- Door Finder (https://fivemad.com/redm/tools/door-finder): Every door RDR2 registers with its door system, on the map. Click one for its door hash and position, and copy vorp_doorlocks or rsg-doorlock rows.
- Imap Toggler (https://fivemad.com/redm/tools/imap-toggler): Find RDR2 imaps (ymaps) by place, name or hash, see which ones only load when a script asks, and copy the Lua that loads or removes them.
- Train Tracks (https://fivemad.com/redm/tools/train-tracks): Every train, trolley, mine cart and riverboat track of RDR2 on the map, with its config group, junctions and the trains it runs.
- Interiors (https://fivemad.com/redm/tools/interiors): Every interior placed in the RDR2 world, on the map and as a list: rooms, portals, entity sets, the imap it needs, and the Lua to switch its sets.
- Folders to YTD (https://fivemad.com/redm/tools/folders-to-ytd): Folders of images in, one RDR2 texture dictionary per folder out, as a RedM resource. Built in your browser, nothing is uploaded.
- Blip Replacer (https://fivemad.com/redm/tools/blip-replacer): Swap RDR2 blip icons for your own pictures and download a RedM resource with the rebuilt blips.ytd, every stock icon carried over.
- Map Editor (https://fivemad.com/redm/tools/map-editor): Draw roads, railways, borders, buildings, water and labels on RDR2's in-game map and download a RedM resource with the rebuilt map tiles. Mainland and Guarma.
# Dataset list
- Blip icons and blip styles (https://fivemad.com/data/rdr3/blips.json): Every blip icon texture of RDR2's blip dictionaries with the blip styles that draw it, plus every blip style of blipdata.ymt with its parent, icon, colour and label. 628 rows, 111 KB. Shape: columns + rows: [texture, hash, hash_signed, dictionary, width, height, styles, label]; styles: { columns, rows: [key, hash, hash_signed, parent, texture, color, label, category] }
- Ped models (https://fivemad.com/data/rdr3/peds.json): Every ped model of RDR2 (people, horses, animals, fish) with its outfit count, a category read from the name, and whether we have a picture of it (/media/rdr3/pedshots/.webp). 1,983 rows, 154 KB. Shape: columns + rows: [model, hash, hash_signed, category, outfits, label, name_source, town_sets, shot]
- Weapons and ammo (https://fivemad.com/data/rdr3/weapons.json): Every weapon of RDR2's weapon list with its group, slot and accepted ammo, plus the ammo types. 142 rows, 32 KB. Shape: columns + rows: [name, hash, hash_signed, kind, group, slot, ammo, label, icon, name_source]; ammo: { columns, rows }
- Vehicles (https://fivemad.com/data/rdr3/vehicles.json): Every vehicle model of RDR2's vehicles.meta files: wagons, coaches, boats, train cars, mounted guns and the balloon. 115 rows, 12 KB. Shape: columns + rows: [model, hash, hash_signed, type, handling, layout, pack, label]
- Props (https://fivemad.com/data/rdr3/props.json): Every RDR2 prop a script can spawn anywhere on the map (measured in game with IsModelValid), with a category read from the name, its size in metres and a picture of each (/media/rdr3/propshots/.webp). 13,290 rows, 938 KB. Shape: columns + rows: [model, hash, hash_signed, category, dims]; dims = [x, y, z] in metres
- Shop catalog items (https://fivemad.com/data/rdr3/shop-items.json): Every item hash of RDR2's story mode and Online shop catalogs, with its game label, inventory icon and the shops that stock it. 18,550 rows, 2.1 MB. Shape: columns + rows: [name, hash, hash_signed, category, label, icon, sets, shops, name_source]
- Inventory icons (https://fivemad.com/data/rdr3/items.json): Every inventory item icon of RDR2's item texture dictionaries, with the game's own label and description where it has one. 1,229 rows, 107 KB. Shape: columns + rows: [name, dict, label, desc, size]
- Documents (https://fivemad.com/data/rdr3/documents.json): Every page of RDR2's item viewer: letters, notes, pamphlets, posters, maps and photos. 378 rows, 60 KB. Shape: columns + rows: [texture, hash, hash_signed, dictionary, kind, width, height, copy, label]
- Scenarios (https://fivemad.com/data/rdr3/scenarios.json): Every scenario RDR2 defines, with its type and the scenario file it comes from. 2,666 rows, 253 KB. Shape: columns + rows: [name, hash, hash_signed, type, file]
- Controls (https://fivemad.com/data/rdr3/controls.json): Every input action of RDR2 with its hash and default pad inputs, plus the prompt hold modes and their timings. 373 rows, 24 KB. Shape: columns + rows: [name, hash, hash_signed, pad_sources, label]; promptHoldModes: { columns, rows }
- Timecycle modifiers (https://fivemad.com/data/rdr3/timecycles.json): Every timecycle modifier of RDR2 with its parameter count and source file. 1,286 rows, 90 KB. Shape: columns + rows: [name, hash, hash_signed, parameters, file]
- Weather types (https://fivemad.com/data/rdr3/weathers.json): Every RDR2 weather type with its short name and the timecycle file it draws with. 22 rows, 5 KB. Shape: columns + rows: [name, hash, hash_signed, short_name, timecycle, sp_only, label]; cycles: { columns, rows }
- Map zones (https://fivemad.com/data/rdr3/zones.json): Every zone of RDR2's mapzones.meta: states, districts, towns and named water, with a bounding box and polygons. 87 rows, 105 KB. Shape: zones: [{ name, hash, type, label, box, hulls }]
- Interiors (https://fivemad.com/data/rdr3/interiors.json): Every interior placed in the RDR2 world: position, rooms, portals, entity sets and the imap it needs. 290 rows, 122 KB. Shape: interiors: [{ hash, name, x, y, z, heading, box, rooms, portals, sets, ymap, ymapName, script }]
- Imaps (https://fivemad.com/data/rdr3/imaps.json): Every map file (imap) of the RDR2 world with its hash, extents, entity count and whether it only loads when a script asks. 7,516 rows, 508 KB. Shape: columns + rows: [hash, name, script, x0, y0, x1, y1, z0, z1, entities, instanced, contentFlags, parent]
- Doors (https://fivemad.com/data/rdr3/doors.json): Every door RDR2 registers with its door system: door hash, model, position, heading and the interior it is in. 1,901 rows, 212 KB. Shape: columns + rows: [hashHex, hash, signed, model, modelHash, x, y, z, heading, interior, interiorName, script, copies]
- Train tracks and train configs (https://fivemad.com/data/rdr3/trains.json): Every train, trolley, mine cart and riverboat track of RDR2 with its points and junctions, plus the train configs and their cars. 28 rows, 84 KB. Shape: tracks: [{ file, config, stopsAtStations, closed, pts, junctions }], groups, configs: [{ hash, name, cars }]
- Game scripts (https://fivemad.com/data/rdr3/scripts.json): Every RDR2 game script (.ysc) of story mode and Online with its code size and how many different natives it calls. 2,195 rows, 157 KB. Shape: columns + rows: [name, hash, hash_signed, set, code_bytes, natives, statics, params, file_bytes]
- Stock file name hashes (https://fivemad.com/data/rdr3/stock-names.json): The hashes of the file names RDR2 itself ships, per file type, so a streamed file can be checked for replacing a stock one. 44,679 rows, 177 KB. Shape: types: { : { count, data } } where data is sorted unique uint32 hashes as LEB128 varint deltas, base64
- Game text (American English) (https://fivemad.com/data/rdr3/text-en.tsv.br): Every American English text label of RDR2. Large; search it with /api/redm/text instead of downloading it. 259,297 rows, 3.8 MB. Shape: brotli compressed TSV: a header line, then hash (8 hex digits), key name (empty when not known), text