RedM vs FiveM Scripting: The Definitive Technical Comparison (2026)

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.

---

What RedM and FiveM Actually Share

Start with what is not different, because it is most of the stack.

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:

-- 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

-- 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, 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, 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:

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:

-- 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

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:

if IsControlJustPressed(0, 51) then -- E

RedM uses input hashes:

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.

---

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, the Cfx.re forums, alloc8or’s Native DB, 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.