Gematria Calculator

Gematria is an ancient alphanumeric coding practice that assigns numerical values to letters, words, and phrases. The system originated in Hebrew mystical traditions at least two thousand years ago, where each letter of the Hebrew alphabet doubles as a numeral. By computing the sum of a word's letter values, practitioners compare seemingly unrelated words that share the same total, looking for hidden meaning. If you are familiar with the letters to numbers converter here on AlphaCoder, you already understand the core mechanic — gematria simply extends that idea across multiple numbering systems and cultural traditions.

The word "gematria" itself likely derives from the Greek word geometria (geometry), reflecting the ancient intertwining of mathematics, language, and mysticism. In Greek tradition, the equivalent practice is called isopsephy. Both systems share the same fundamental logic: letters are numbers, and the sum of a word is a single value that can be compared to other sums.

Our calculator computes four distinct systems simultaneously. Understanding each one helps you appreciate the range of values a single word can produce.

1. English Ordinal (A=1, Z=26): The simplest system. Each letter equals its position in the English alphabet. This is identical to the A1Z26 cipher used in cryptography and puzzles. The word "GOD" in ordinal gematria is 7+15+4 = 26 — a number that gematria enthusiasts note is also the count of letters in the English alphabet.

2. Full Reduction (Pythagorean):Each letter's ordinal value is reduced to a single digit by summing its digits repeatedly. K (11) becomes 1+1=2. Z (26) becomes 2+6=8. All values fall between 1 and 9. This system compresses the range dramatically, making numerical matches between words much more common.

3. Reverse Ordinal (Z=1, A=26): The alphabet is flipped. Z=1, Y=2, X=3, up to A=26. This creates a mirror-image value landscape. The word "GOD" in reverse ordinal is 20+12+23 = 55, very different from its ordinal value of 26. Practitioners sometimes compare forward and reverse values for the same word.

4. Reverse Full Reduction: The reverse ordinal value of each letter is reduced to a single digit. This gives the tightest range and the highest probability of coincidental matches between words.

The Hebrew alphabet has 22 letters, and their gematria values follow a non-linear scale. The first nine letters (Aleph through Tet) are valued 1-9. The next nine (Yod through Tsade) are 10, 20, 30, 40, 50, 60, 70, 80, 90. The final four (Qof through Tav) are 100, 200, 300, 400. Five letters have special final forms (sofit) that some systems value at 500-900.

A famous example: the Hebrew word chai (meaning "life") consists of Chet (8) and Yod (10), totaling 18. This is why 18 is considered an auspicious number in Jewish tradition, and why monetary gifts are often given in multiples of 18. The system creates a rich web of numerical connections throughout the Torah that scholars and mystics have explored for millennia.

Our calculator focuses on English-alphabet systems because Hebrew gematria requires Hebrew character input and the specialized letter-value table described above. For exploring how English letters map to simple numbers, the history of ciphers article provides broader context.

Example 1: "HELLO"
Ordinal: H(8)+E(5)+L(12)+L(12)+O(15) = 52
Full Reduction: H(8)+E(5)+L(3)+L(3)+O(6) = 25
Reverse Ordinal: H(19)+E(22)+L(15)+L(15)+O(12) = 83
Reverse Reduction: H(1)+E(4)+L(6)+L(6)+O(3) = 20

Example 2: "GEMATRIA"
Ordinal: G(7)+E(5)+M(13)+A(1)+T(20)+R(18)+I(9)+A(1) = 74
Full Reduction: G(7)+E(5)+M(4)+A(1)+T(2)+R(9)+I(9)+A(1) = 38
Reverse Ordinal: G(20)+E(22)+M(14)+A(26)+T(7)+R(9)+I(18)+A(26) = 142
Reverse Reduction: G(2)+E(4)+M(5)+A(8)+T(7)+R(9)+I(9)+A(8) = 52

Notice that "HELLO" has an ordinal value of 52, and "GEMATRIA" has a reverse reduction of 52. In gematria practice, this kind of cross-system match is what enthusiasts look for — though statistically, such coincidences are expected to occur frequently given the many available systems.

Here is a concise JavaScript implementation that computes all four English gematria systems:

function gematria(word) {
  const letters = word.toUpperCase().split('').filter(
    ch => ch >= 'A' && ch <= 'Z'
  );
  const reduce = n => {
    while (n > 9) n = [...String(n)].reduce((s,d) => s + +d, 0);
    return n;
  };
  let ordinal = 0, fullRed = 0, revOrd = 0, revRed = 0;
  for (const ch of letters) {
    const pos = ch.charCodeAt(0) - 64;   // A=1
    const rev = 27 - pos;                // Z=1
    ordinal  += pos;
    fullRed  += reduce(pos);
    revOrd   += rev;
    revRed   += reduce(rev);
  }
  return { ordinal, fullRed, revOrd, revRed };
}

console.log(gematria("Hello"));
// { ordinal: 52, fullRed: 25, revOrd: 83, revRed: 20 }

And the Python equivalent:

def reduce(n):
    while n > 9:
        n = sum(int(d) for d in str(n))
    return n

def gematria(word):
    letters = [c for c in word.upper() if c.isalpha()]
    ordinal = sum(ord(c) - 64 for c in letters)
    full_red = sum(reduce(ord(c) - 64) for c in letters)
    rev_ord = sum(27 - (ord(c) - 64) for c in letters)
    rev_red = sum(reduce(27 - (ord(c) - 64)) for c in letters)
    return ordinal, full_red, rev_ord, rev_red

print(gematria("Hello"))
# (52, 25, 83, 20)