FiveM JOAAT Hash Generator

What is a JOAAT hash?

JOAAT stands for Jenkins one-at-a-time, a small, fast, non-cryptographic hash function published by Bob Jenkins. Rockstar's RAGE engine — the engine behind GTA V and, by extension, FiveM — uses it everywhere to turn human-readable names into compact 32-bit integers. Instead of storing the string "weapon_pistol" in a save file or a meta reference, the game stores its JOAAT hash, 0x1B06D571. Comparing two 32-bit numbers is far cheaper than comparing two strings, so the engine hashes once and works with integers from then on.

One detail trips up almost everyone: the engine hashes the lowercased form of the string. That means WEAPON_PISTOL, Weapon_Pistol, and weapon_pistol all produce the same hash. This generator lowercases automatically before hashing, so you always get the value the game actually uses.

Where JOAAT hashes show up in FiveM

Once you know to look, hashes are everywhere. A few of the most common places:

• Model hashes — vehicles, peds, props, and weapons are all spawned by hash. Natives like CreateVehicle and GetHashKey('adder') expect the JOAAT of the model name.
• Weapon hashes — every weapon is referenced by the hash of its name, e.g. weapon_pistol → 0x1B06D571.
• audioNameHash — vehicle audio in vehicles.meta points at a sound set by name; the game resolves it through JOAAT. Custom sirens and engine sounds rely on getting this exactly right.
• Animation dictionaries, particle (ptfx) names, and radio stations — many meta fields and natives accept either a string or its precomputed hash.

How the algorithm works

Jenkins one-at-a-time processes the input one byte at a time. For each byte it adds the byte to the running hash, then mixes the bits with a shift-and-add followed by a shift-and-xor. After the last byte, three final mixing steps avalanche the result so that changing a single character produces a completely different hash. Everything is kept inside an unsigned 32-bit integer, wrapping on overflow.

hash = 0
for each byte b in lowercase(input):
    hash += b
    hash += hash << 10
    hash ^= hash >> 6
hash += hash << 3
hash ^= hash >> 11
hash += hash << 15   // final 32-bit result

Worked examples

These are documented GTA V hashes you can verify with the generator above:

Unsigned, signed, or hex?

The hash is fundamentally an unsigned 32-bit integer, but you will see it written three ways. Unsigned (0 to 4,294,967,295) is the canonical form. Signedis the same 32 bits interpreted as a two's-complement integer, so any hash above 2,147,483,647 shows up negative — common in C# and some database dumps. Hex (e.g. 0x1B06D571) is the most compact and is what you will most often see in decompiled scripts and meta files. All three above describe the same value; this tool prints every representation so you can paste whichever your code expects.

Using a hash in your script

In Lua you rarely need to precompute a hash — you can pass a name and let GetHashKey do it at runtime — but precomputing is handy for lookup tables, config files, and comparing against values the game already stored as hashes.

-- Lua (FiveM)
local model = GetHashKey('adder')        -- or joaat('adder')
RequestModel(model)

-- Precomputed (from this tool)
local WEAPON_PISTOL = 0x1B06D571
if GetSelectedPedWeapon(ped) == WEAPON_PISTOL then
    -- ...
end

Frequently asked questions