How Love Tester Actually Works Under the Hood
Love Tester is one of those browser games that looks deceptively simple. You type two names, hit calculate, and it spits out a percentage. Most people treat it as a party trick and move on, but the algorithm behind it is worth looking at because it reveals how these types of novelty games are built. The game runs entirely client-side. There's no server processing your names. Everything happens in the browser using JavaScript, which means the result is deterministic based on the string values you input. The basic approach takes the character codes of each letter in both names, multiplies them or adds them together in some sequence, then normalizes the result to a 0-100 range using a modulo operation. I built something similar for a side project a few years back. The first version I wrote produced identical results for names with the same letters in different orders because I was only summing character values without any positional weighting. Anagram inputs like "listen" and "silent" would return the same percentage, which defeated the purpose. The fix was straightforward: multiply each character's ASCII value by its position index before summing. That way "ab" and "ba" produce different results. This is probably the most common bug I see when people try to reverse-engineer or recreate these games.
Cool Math Games likely uses a more refined version of this. The exact implementation isn't public, but based on testing various name pairs, the algorithm probably incorporates a hash function rather than raw arithmetic. This explains why very similar names don't always produce marginally different results — a good hash function creates significant output variation from small input changes, which makes the percentages feel more random even though they're completely deterministic. Here's the practical breakdown of how to use it. Navigate to the Cool Math Games website, find Love Tester in their collection, and enter two full names into the input fields. The game doesn't validate the input format, so nicknames, spaces, and special characters all get processed — though some characters may not map cleanly depending on how the underlying code handles non-ASCII input. Hit the calculate button and the result appears instantly. There's a subtlety most players miss. The game typically normalizes input by converting everything to lowercase and stripping whitespace before running the calculation. This means "John Appleseed" and "john appleseed" will always return identical results, but "John Appleseed" and "johnappleseed" might diverge depending on whether the whitespace removal happens before or after the normalization step. Testing this empirically is the only way to know exactly which version Cool Math Games uses.
If you want to try it yourself, the game is freely available on the Cool Math Games website. No download required, no account needed. It's designed to run in any modern browser. However, if you're trying to embed it or build a clone for a project, be aware that the exact algorithm is proprietary and replicating the output distribution precisely will require reverse engineering through input-output testing. The main limitation of Love Tester is that it's fundamentally a pseudorandom generator dressed up as an algorithm. The results have no predictive value whatsoever. People sometimes treat these games seriously in group settings, which can create awkward situations. I once watched a work event derail when someone took their love test result too literally and confronted their coworker about it. The game doesn't know anything about human relationships. It knows character codes and modulo arithmetic. For anyone interested in the technical side, the core loop is essentially: accept string input, hash or transform it into a numeric value, apply normalization and scaling, render the result. The complexity comes from making the output feel sufficiently unpredictable while remaining deterministic. That tension between apparent randomness and actual predictability is what makes these games interesting to deconstruct.
Get the Full Details
If you're building something similar, start with a simple character-weighted sum, test it against a large sample of name pairs to check for collision patterns, then layer in a proper hashing function if the distribution feels too clustered. The whole process from empty file to working prototype usually takes about twenty minutes on a first attempt, longer if you're obsessing over edge cases like unicode characters or extremely long name strings.
