<!-- fivemad.com, Markdown source of https://fivemad.com/docs/tools/hash-calculator -->
> Source: https://fivemad.com/docs/tools/hash-calculator
> Section: Tools
> Tags: hashes, joaat, GetHashKey, backtick, model hash
> Tool: https://fivemad.com/tools/hash-calculator
> Last updated: 2026-09-25
> Site map for assistants: https://fivemad.com/llms.txt

# joaat Hash Calculator

Turn any model, weapon or asset name into its GTA V joaat hash in unsigned, signed and hex form, one at a time or as a bulk Lua table.

The joaat Hash Calculator turns any string into the 32-bit hash GTA V uses for it, the same value `GetHashKey`, `joaat` and the Lua backtick give you in game. It is for anyone who needs a hash outside the game: comparing a value from a log, filling a config, or building a lookup table for a script.

Every snippet block on this page has a **Lua / JS / TS / C#** switcher in its corner. The choice is remembered across the site, and [the runtimes page](/docs/development/runtimes) explains what changes between them.

## What it is for

GTA V (and RDR2) identify models, weapons, animations, components and most other assets by a Jenkins one-at-a-time hash of their lower-cased name. You meet those numbers everywhere: `GetEntityModel` returns one, weapon events carry one, and dumps print them in different formats. When a script prints `-1216765807` and you want to know if that is `adder`, or when you need a hash table for a whitelist, this tool gives you the number without starting the game.

## Quick start

1. Open the tool. The **Single** tab is selected, with `adder` already typed in.
2. Type your string in the **String** field. The **Result** panel updates on every key press.
3. Click any value in the result to copy it.
4. For many names at once, switch to **Bulk**, paste one name per line, pick an **Export format** and copy the generated `hashes.lua`.

## Single mode

The **Result** panel shows four rows for the current string:

| Row | Example for `adder` | Notes |
| --- | --- | --- |
| **Unsigned** | `3078201489` | The raw 32-bit value, 0 to 4294967295. |
| **Signed (int32)** | `-1216765807` | Same bits read as a signed int32. What most natives return and many dumps print. |
| **Hex** | `0xB779A091` | Always `0x` plus 8 upper-case digits. |
| **Lua backtick** | `` `adder` `` | Your string lower-cased inside backticks, ready to paste into Lua. |

The input is lower-cased before hashing, exactly like the game does, so `ADDER`, `Adder` and `adder` all give the same result. `WEAPON_PISTOL` and `weapon_pistol` are the same hash too.

## Bulk mode

Paste one string per line in **One string per line**. Empty lines are skipped and spaces around each line are trimmed. The panel title shows how many hashes were computed, and the table lists each name with its **Signed** and **Hex** value (click to copy).

Below the table, **Export format** (**Hex**, **Signed** or **Unsigned**, default Hex) controls the value used in the generated `hashes.lua` block:

```lua title="hashes.lua"
local Hashes = {
    adder = 0xB779A091,
    zentorno = 0xAC5DF515,
    WEAPON_PISTOL = 0x1B06D571,
    mp_m_freemode_01 = 0x705E61F2,
    prop_bench_01a = 0x6BA514AC,
}
```

Names that are valid Lua identifiers become plain keys. Anything else (a name with a dash or starting with a digit) is written as `["name"]`, so the table always parses.

## Examples

Reverse lookup of a model you got from the game, using a table built in bulk mode:

```lua title="client.lua"
local Names = {
    [`adder`] = "adder",
    [`zentorno`] = "zentorno",
}

local veh = GetVehiclePedIsIn(PlayerPedId(), false)
local model = GetEntityModel(veh)
print(Names[model] or ("unknown model %d"):format(model))
```

The backtick is resolved when the script is compiled, so it costs nothing at runtime:

```lua
local model = `adder`
RequestModel(model)
while not HasModelLoaded(model) do Wait(0) end
local veh = CreateVehicle(model, coords.x, coords.y, coords.z, heading, true, false)
SetModelAsNoLongerNeeded(model)
```

## Signed vs unsigned

The hash itself is unsigned, but natives hand it to Lua as a signed int32, so `GetEntityModel` on an Adder returns `-1216765807`, not `3078201489`. Both are the same model. In Lua, compare against the backtick or `GetHashKey` result instead of a hard-coded unsigned number, and the sign never gets in the way. Hex literals like `0xB779A091` are positive in Lua 5.4, so a table keyed by hex will not match a signed value from a native. Pick **Signed** as the export format when you compare against values returned by natives.

> [!TIP]
> Use **Signed** when the table is compared with `GetEntityModel`, `GetSelectedPedWeapon` or event payloads. Use **Hex** when you want readable values in a config that is only passed back into natives.

## Common mistakes

- Hashing a display name. `Adder` is fine because case does not matter, but "Truffade Adder" is not the model name. Use the spawn name.
- Adding spaces or a file extension. `adder.yft` hashes to something else entirely.
- Comparing a signed value from a native with an unsigned or hex constant.

## Limitations

- The tool only hashes. It does not look a hash up to find the name. For vehicles, peds and weapons, the [Model & Hash Browser](/tools/model-hash-browser) lists spawn names next to their signed, unsigned and hex hashes.
- Everything runs in your browser. Nothing you type is sent anywhere.

## Related tools

- [Model & Hash Browser](/docs/tools/model-hash-browser)
- [Weapon Stats & Components](/docs/tools/weapon-stats)
- [Objects / Props List](/docs/tools/objects-list)
- [Player Stats List](/docs/tools/player-stats)