# RedM vs FiveM Scripting: The Definitive Technical Comparison (2026) URL: https://redmorrow.com/blog/redm-vs-fivem-scripting Published: 2026-08-31 Author: Kia Sin Publisher: RedMorrow > RedM and FiveM share an engine, but only 39% of RDR2's 7,132 natives are named. A code-level comparison of the native tax, prompts, horses and MLOs. Choosing between RedM and FiveM looks like a game preference. It is actually a decision about how much undocumented engine work you are willing to absorb. Both platforms are built by **Cfx.re**, both run the same server binary, and both use the same manifest format. If you can write a FiveM resource you already understand 80% of RedM's plumbing. The other 20% is where projects stall, because RedM asks you to work with an engine that the community is still reverse-engineering in public. This article is a code-level comparison of that 20%. It is written for developers deciding which platform to build on, and for FiveM developers being asked to quote for a RedM job.
Two code blocks side by side: a short clean block marked with a green check, and a longer block full of hexadecimal hashes marked with a red warning
The hashed-native tax: the same operation, expressed with a named wrapper on FiveM and a raw hash on RedM.
--- ## What RedM and FiveM Actually Share Start with what is not different, because it is most of the stack.
A 1899 frontier town at sunset on the left, a neon modern city street at night on the right, split down the middle
Two different games, one shared engine, server binary and manifest format.
FiveM modifies **Grand Theft Auto V**. RedM modifies **Red Dead Redemption 2**, which runs a newer iteration of the same RAGE engine. Both are projects of Cfx.re, which **Rockstar Games acquired on 11 August 2023**. Rockstar's Newswire post put it plainly: > Today, we are proud to announce that Cfx.re, the team behind the biggest Rockstar roleplay and creator communities, FiveM and RedM, are now officially a part of Rockstar Games. Shared between them: - The same **FXServer** binary and the same **txAdmin** management panel - The same resource system and `fxmanifest.lua` manifest format - The same three runtimes: **Lua** (CfxLua, with Lua 5.4 via `lua54 'yes'`), **JavaScript** (V8 and a customised Node on the server, ES2017 without DOM or Node APIs on the client) and **C#** (a limited Mono subset) - The same `fx_version` codenames: `adamant` and `bodacious` are legacy, `cerulean` has been the standard since 2021 ### The manifest difference Every resource needs an `fxmanifest.lua`. The game declaration is where they part: ```lua -- FiveM fx_version 'cerulean' game 'gta5' -- RedM fx_version 'cerulean' games { '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.' ``` That `rdr3_warning` line is mandatory on RedM. It is an explicit acknowledgement that the platform is still a work in progress, and it tells you something about the maturity gap before you have written a single line of logic. ### Game builds FiveM has a long build ladder driven by `sv_enforceGameBuild`: 1604, 2060, 2189, 2372, 2545, 2612, 2699, 2802, 2944, 3095, 3258 and 3407, plus the Legacy and Enhanced split. FiveM developers spend real time wrestling with build-gated natives and DLC content. RedM has four practical builds and that is the whole list: | Build | Released | Notes | |---|---|---| | 1311 | Mid-2020 | Oldest commonly supported | | 1355 | December 2020 | | | **1436** | July 2021 | Blood Money DLC, the most common choice | | 1491 | September 2022 | Newest | Fewer choices is genuinely easier. You pick one, usually 1436, and move on. --- ## Natives: The Single Biggest Difference This is the section most comparisons skip, and it is the one that determines how long a RedM job actually takes. FiveM's native reference documents **7,356 natives for GTA V and Cfx.re**, virtually all named, with clean typed wrappers. RedM's canonical community reference is **alloc8or's RDR2 Native DB**, which currently reports: > Namespaces: 86 | Natives: 7132 | Comments: 2161 | Known names: 2806 Read those two numbers together. RDR2 exposes a comparable *quantity* of natives, but only **2,806 of 7,132 are named**. Roughly **61% remain raw hashes**. ### What that means in practice Three concrete consequences, every day: 1. **RedM code is saturated with `Citizen.InvokeNative(0x...)`** because a named wrapper does not exist for most natives. 2. **A leading underscore marks a community-assigned name.** `_SET_ATTRIBUTE_CORE_VALUE` was named by the community; names without an underscore are Rockstar's originals, recovered from symbol data. 3. **You cast return values yourself.** Raw invokes need `Citizen.ResultAsInteger()`, `Citizen.ResultAsString()`, `Citizen.ResultAsFloat()`, `Citizen.PointerValueInt()`, `Citizen.PointerValueFloat()` and `Citizen.ReturnResultAnyway()`. FiveM's named wrappers marshal automatically. That overhead is the **hashed-native tax**. It is not a vague complaint about documentation, it is a measurable productivity difference. ### The same job on both platforms ```lua -- FiveM: clean named wrapper throughout local hash = GetHashKey("a_m_m_farmer_01") RequestModel(hash) while not HasModelLoaded(hash) do Wait(0) end local ped = CreatePed(hash, x, y, z, heading, true, false) SetModelAsNoLongerNeeded(hash) -- RedM: CreatePed exists, but ped setup routinely drops to raw invokes local hash = GetHashKey("A_C_Horse_KentuckySaddle_Grey") RequestModel(hash) while not HasModelLoaded(hash) do Wait(0) end local ped = CreatePed(hash, x, y, z, heading, true, false, false, false) Citizen.InvokeNative(0x283978A15512B2FE, ped, true) -- _SET_RANDOM_OUTFIT_VARIATION ``` ### Where to look things up **RedM:** [alloc8or's Native DB](https://alloc8or.re/rdr3/nativedb/), the `alloc8or/rdr3-nativedb-data` repository, rdr3natives.com, rdr2mods.com/nativedb, redlookup, Cfx's machine-readable `natives_rdr3.json`, and **femga/rdr3_discoveries**, a large community dump of weapon hashes, AI flags, scenarios and animations. **FiveM:** [docs.fivem.net/natives](https://docs.fivem.net/natives/), the `citizenfx/natives` repository, and `Citizen.InvokeNative` for the rare undocumented case. There is even a `PichotM/fivem-redm-wrapper` project attempting automatic translation, which tells you how much manual porting the community does by hand. --- ## Text, Blips and the Prompt System These three catch out nearly every new RedM developer, and they are all UI. ### VarString is the number one gotcha Almost all UI and native text on RedM has to be wrapped before the game will render it: ```lua local str = Citizen.InvokeNative(0xFA925AC00EB830B9, 10, 'LITERAL_STRING', "Press Me") -- CreateVarString ``` Pass a plain Lua string to most text natives and you get nothing on screen, with no error. If your first RedM UI renders blank, this is why. ### Blips use hashes, not integers FiveM uses integer sprite IDs. RedM uses hashed sprite names and raw invokes: ```lua -- FiveM local blip = AddBlipForCoord(x, y, z) SetBlipSprite(blip, 564) -- RedM local blip = Citizen.InvokeNative(0x554D9D53F696D002, 1664425300, x, y, z) -- BlipAddForCoords SetBlipSprite(blip, GetHashKey("blip_ambient_horse"), true) -- hash, not integer SetBlipScale(blip, 0.2) Citizen.InvokeNative(0x9CB1A1623062F402, blip, name) -- set name ``` ### The prompt system has no FiveM equivalent RedM's signature native UI is the prompt: `PromptRegisterBegin`, `UiPromptSetControlAction`, `PromptSetGroup`, with hold and press modes and timed events. It is the idiomatic RedM interaction pattern, and there is nothing like it in GTA V. It is also limited. You get roughly ten prompts on screen before you need group tabs, and some controls simply will not render one. **NUI works identically on both** (`SendNUIMessage`, `RegisterNUICallback`, `SetNuiFocus`), which is how most complex RedM interfaces are actually built. Many teams sidestep the native UI entirely. --- ## Horses Are Peds, Not Vehicles
Flat illustration of a saddled horse in red on the left and a modern car in blue on the right, in matching geometric style
RedM keeps wagons, boats and trains, but the platform's real "vehicle" is a ped with a bonding level.
FiveM's vehicle system is deep and mature: classes, `handling.meta`, `SetVehicleModKit`, tuning, server-side `CreateVehicle` and custom vehicle streaming. RedM keeps RAGE-era vehicles (wagons, carriages, boats, canoes and **trains** via `_CREATE_MISSION_TRAIN` and `SetTrainSpeed`), but the platform's actual mount is the **horse**, and a horse is a **ped**: - **Mounting:** `SetPedOnMount`, `GetMount`, `IsPedOnMount` - **Bonding:** `SetPedHorseBondingLevel`, four levels unlocking abilities like sidestep and drift - **Cores:** stamina and health cores rather than a flat health bar - **Components:** saddles, blankets, stirrups, saddlebags, manes and tails Frameworks like `rsg-horses` build ownership, XP and levelling, ageing, trading and stable systems on top of these. The persistence patterns mirror owned-vehicle persistence in FiveM frameworks, but essentially none of the code transfers. --- ## Peds, Clothing and the Update Trap GTA V uses drawable and texture component variation: `SetPedComponentVariation(ped, componentId, drawable, texture, palette)` and `SetPedPropIndex`. RedM uses a completely different **metaped, component-tag and shop-item** system: `ApplyShopItemToPed`, `EquipMetaPedOutfit`, `SetPedComponentEnabled`, `_UpdatePedVariation`, then `IsPedReadyToRender`. The notorious gotcha: **model and clothing changes are invisible to other players until you force a variation update.** The common workaround is re-applying a texture change roughly a second after the model loads. If your character creator works locally and looks wrong to everyone else, that is the bug. Animals are also a first-class ped category on RedM, with tintable textures and rich variation. GTA V has that only marginally. --- ## Weapons, Cores and Dead Eye FiveM's weapon model is hashes, `GiveWeaponToPed`, components and `weapons.meta`, with flat health and armour. RedM is richer and specifically Red Dead flavoured: | System | FiveM | RedM | |---|---|---| | Health model | Flat health and armour | Inner and outer **cores** for health, stamina and Dead Eye | | Ammo | Standard types | Express, high-velocity, split-point, explosive | | Condition | None | Weapon degradation and cleaning | | Special ability | None comparable | **Dead Eye**, plus the RDO ability-card system | The cores system runs through `_SET_ATTRIBUTE_CORE_VALUE` (`0xC6258F41D86676E0`), `_GET_ATTRIBUTE_CORE_VALUE` (`0x36731AC041289BB1`), `ENABLE_ATTRIBUTE_OVERPOWER` (`0x4AF5A4C7B9157D14`) and `ADD_ATTRIBUTE_POINTS` (`0x75415EE0CB583760`). The `ATTRIBUTE` namespace holds 27 natives and replaces GTA V's health model entirely. One practical trap: `GIVE_WEAPON_TO_PED` (`0x5E3BDDBCB83F3D84`) takes more parameters than FiveM's and is a **client** native, so a server has to trigger a client event to arm a player. --- ## The MLO Gap This is RedM's hardest ceiling, and the one worth understanding before you promise a client an interior. Both platforms stream raw `.ymap` and `.ytyp` files. FiveM's `stream/` folder maturity (ymap, ytyp, ydr, ytd, ycd) and, crucially, **MLO interiors with portals, rooms and occlusion** are its biggest world-building advantage. **RedM has effectively no true MLO or interior portal support.** Community mappers work around it with interior shells, restreamed original ymaps, and custom Blender, CodeWalker and OpenIV workflows. The free "Rhodes Doctor" release is a good demonstration of rdr3 shaders and restreamed ymaps. Any guide advertising "MLOs for RedM" is describing those workarounds. Price accordingly. --- ## Controls and Input FiveM uses **integer control IDs** with control groups 0, 1 and 2, and a documented reference list: ```lua if IsControlJustPressed(0, 51) then -- E ``` RedM uses **input hashes**: ```lua if IsControlJustPressed(0, 0xCEFD9220) then -- E -- 0x07CE1E61 mouse1, 0x4CC0E2FE B ``` RedM also has a control **context** system, `SetControlContext(0, GetHashKey("OnFoot"))`, which must be reset after you take control for a UI. Forget it and the player is left unable to move, which is a support ticket waiting to happen. --- ## Security: Identical Rules, Fewer Safety Nets Both platforms share the same trust model and the same core vulnerability: **the client cannot be trusted.** FiveM's official anti-cheat is a global, delayed-ban injection detector. It does **not** cover in-game cheats such as aimbot, ESP or noclip, and it does not cover event exploits. Server owners build their own protections on both platforms. This matters more on RedM, because the anti-cheat ecosystem is overwhelmingly built for FiveM. RedM operators inherit fewer off-the-shelf defences and have to lean harder on correct server-side design. Event security is mechanically identical: - `RegisterNetEvent` only allows an event to **cross the network boundary**. It does not authenticate the caller. Anyone with a Lua executor can call `TriggerServerEvent` with arbitrary arguments. - The classic exploit is `TriggerServerEvent("shop:buyItem", "gold_bar", 9999)` against a handler that trusts client input. - The defence: validate everything server-side, read money and items from trusted server state, rate-limit per operation, and for server-only client events check `if source ~= 65535 then return end`. Useful convars on both: `sv_authMinTrust`, `sv_filterRequestControl`, `sv_disableClientReplays`, ACE permissions via `add_ace` and `add_principal`, and keeping `sv_scriptHookAllowed` off. **Asset Escrow** exists on both now, though RedM's arrived years after FiveM's 2021 launch. NUI cannot be escrowed. Escrowed resources require `lua54 'yes'`, server artifacts 4960 or newer, and Tebex distribution. --- ## Frameworks and Ecosystem | Layer | FiveM | RedM | |---|---|---| | Dominant frameworks | ESX, QBCore, Qbox, ox_core, vRP | **VORP Core**, **RSGCore**, RedEM:RP, QBR-Core | | Standard libraries | ox_lib, ox_inventory, ox_target, oxmysql, PolyZone | oxmysql, BCC utils, framework-specific libraries | | Age | 10+ years, thousands of resources | VORP from June 2020, RSG from early 2023 | | Marketplace | Huge | Small, in the hundreds of scripts | **VORP** is the most established RedM framework, claiming over 1,000 server owners, originally written in C# and migrated to Lua for accessibility. **RSGCore**, by Rexshack, is the QBCore analogue, built deliberately to ease FiveM developer migration. We wrote a data-led breakdown of exactly how those compare, using live server counts, in [our RedM framework comparison](/blog/best-redm-framework-vorp-rsgcore-redem-qbcore). --- ## Scale and Market Reality Be honest about the size difference before you commit a year to a project. | Metric | FiveM | RedM | |---|---|---| | Concurrent players | **300,000+** (January 2024) | ~5,000 typical live counter | | Servers | ~24,500 (2021 recap) | **300+** | | Unique players | 200,000+ on Steam alone | **140,000** historical (January 2022) | | Players per server | Hundreds via OneSync Infinity | **~31 to 32 in scope** | Cfx.re's January 2024 Community Pulse recorded FiveM passing 300,000 concurrent players for the first time. The January 2022 recap stated of RedM: *"we have had 140,000 unique players, being served by over 300 servers."* That ~31 to 32 player scope cap is a defining structural constraint, documented in GitHub issue #2932 and still discussed on the Cfx.re forums in 2026. Experimental work in PR #3477 has tested extension toward roughly 60, but it is not production-ready and no script author can work around the current limit. **The business angle is genuine but narrow.** RedM's scarcity of skilled developers means RedM work commands a premium. The total addressable market is also two orders of magnitude smaller. It is a niche-premium play, not a volume one. --- ## Porting a FiveM Script to RedM If you are quoting for this work, here is what actually transfers. **Ports cleanly:** - Business logic and state machines - Database code and queries - Server-side validation and permissions - NUI interfaces, HTML, CSS and JavaScript **Has to be rewritten:** - Ped and clothing handling, for the metaped and shop-item system - Blips, for hashed sprites - All UI text, for `VarString` - Controls, for input hashes and control contexts - Anything vehicle-related, for horses, wagons and trains - Health and armour logic, for the cores system - Any native interaction UI, for the prompt system Start on **RSGCore** if you are coming from QBCore. It was built to ease that exact migration. --- ## Which Should You Build On? **Choose FiveM if** you want the largest player base, the deepest resource ecosystem, MLO interiors and the easiest hiring path. It is the lower-risk commercial choice and the better platform to learn Cfx scripting on. **Choose RedM if** your community specifically wants Western roleplay, you value differentiation, and you or your developers can absorb the hashed-native tax. Budget materially more time and money for custom development, because you will commission rather than download much of your content. Two things should change your plan if they happen: 1. If the ~32 player scope cap is officially lifted, RedM becomes far more viable for large-scale roleplay and its economics improve. 2. If Rockstar ships official GTA 6 creator tooling, reassess long-term investment in **both** platforms. --- ## A Note on Sources Figures here come from primary sources: [docs.fivem.net](https://docs.fivem.net/), the [Cfx.re forums](https://forum.cfx.re/), [alloc8or's Native DB](https://alloc8or.re/rdr3/nativedb/), and the VORPCORE, Rexshack-RedM, ESX and Overextended GitHub organisations. Some caveats worth stating plainly: - RedM's ~5,000 concurrent figure is a live counter and fluctuates. The firmest RedM numbers remain Cfx.re's "140,000 unique players, over 300 servers" from January 2022. Treat all of these as order-of-magnitude contrasts, not current daily averages. - The ~31 to 32 player scope cap is historically accurate but under active development. Do not assume it is permanent. - Native counts change constantly as the community names more hashes. The 7,132 and 2,806 RedM figures and the 7,356 FiveM figure are recent snapshots. - Several low-quality sites repeat overlapping claims about both platforms. Where they were the only source for a specific number, we left it out. - Niche native hashes for weapon cleaning, Dead Eye toggles and cores values come from community dumps. Re-verify them against alloc8or's DB before shipping production code.