# Ninjabrain Bot: a stronghold calculator that admits your aim is wrong

> Ninjabrain Bot is a GPLv3 licensed Java tool for Minecraft speedrunning that ranks possible stronghold locations using Bayesian inference over eye throws, your own measurement error and the game's stronghold generation rules. The judgement is that modelling the player rather than the world is the interesting part, and that the settings for standard deviation decide whether the percentages mean anything at all.

**Ninjabrain1/Ninjabrain-Bot** — Accurate stronghold calculator for Minecraft speedrunning.

- Repository: https://github.com/Ninjabrain1/Ninjabrain-Bot
- Stars: 838 · Forks: 106
- Language: Java
- License: GPL-3.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/ninjabrain1-ninjabrain-bot

## A locator that ranks candidates instead of picking one

Ninjabrain Bot is an accurate stronghold calculator for Minecraft speedrunning, and the first thing to understand about it is that it does not return a single coordinate. It produces ranked locations with an estimated confidence for each, so a run of several throws narrows a list rather than fixing a point on the map. The mechanism is Bayesian inference combining three inputs, the eye measurements you take in game, the error in your own aim, and Minecraft's stronghold generation mechanics, which constrain where a stronghold can sit in the world. The README points to a derivation of the core algorithm in a document called triangulation.pdf, and that is the reference to read if you want to know why the numbers behave the way they do rather than trusting them. The tool runs as a Java application, the repository is built with a Maven pom, and the workflow is deliberately short enough to fit in a run.

## Two throws and a hotkey

The quick start is four steps. You download the latest release, you run the downloaded JAR, you throw an eye of ender, look directly at it, and press the hotkey:

```bash
F3+C
```

Then you move to a new position and repeat. Each throw is another observation, and the calculator ranks the potential stronghold locations and shows how confident it is in the predictions. The hotkey is the whole interface, which is the design point, because a speedrun is not the moment to open a configuration panel. The repository also carries an animated GIF of the tool calculating a stronghold from two eye throws, and two video guides, a beginner guide from 2026 by K4yfour and a longer one by Four, which is a better way to learn the workflow than the README alone. The same idea appears in the feature list, where the core calculator promises prediction from any number of eye throws, so the accuracy of the ranking improves as you add throws rather than being fixed by the first one.

## Why plain triangulation is not enough

The How it works section explains the problem the tool solves. Traditional triangulation intersects the lines created by two eye throws and effectively assumes that both angles were measured perfectly, but in practice manually aiming at an eye introduces error, especially over long distances. Ninjabrain Bot treats each measured angle as a noisy observation. It uses a calibrated normal distribution to model the player's measurement error, then applies Bayes' theorem to update the probability of candidate stronghold chunks after every throw. The prior model is where the game knowledge enters, since it accounts for stronghold rings, chunk and biome snapping, and the fact that an eye points towards the nearest stronghold. The displayed certainty is an estimated probability produced by this model, and the README is direct that its reliability depends on the model's assumptions and on using a standard deviation that reflects your real measurement accuracy. That sentence is the most important thing in the documentation for anyone tempted to treat the percentage as a fact.

## The standard deviation setting is the load bearing one

Almost every other setting in this tool is cosmetic next to standard deviation, which describes how accurately you measure eye angles. A lower value tells the calculator to trust your readings more, and setting it lower than your real measurement error makes the result overconfident. The README gives typical ranges so you can start somewhere sensible, 0.050 to 0.200 when measuring in Quake Pro, 0.020 to 0.040 at 30 FOV, and 0.005 to 0.010 at 30 FOV with subpixel adjustment, and it points to a Calibrate standard deviation entry in the advanced settings that estimates your value. Accuracy also varies with field of view, resolution, mouse sensitivity and experience, which is why a single number cannot be right for everyone. Crosshair correction is the second setting that can move the answer, since it compensates for crosshair misalignment caused by certain combinations of resolution and in-game settings, and the listed values are 0.026 for 1440p fullscreen with GUI scale 3 and 0.104 for 1440p fullscreen with GUI scale 6 or Auto, with the instruction to leave it at 0 if your setup is not listed.

## Subpixel adjustment, display options and diagnostics

Three smaller features help you get more out of the same throws. Subpixel adjustment lets you nudge the last angle manually, with hotkeys assigned in the advanced settings for plus or minus 0.01 to last angle, and the README notes that at a resolution of 1920 by 1027 an eye with a wide middle eye slit may require pressing the plus hotkey. The Display stronghold location setting only changes how the prediction is presented and does not affect accuracy, with 4, 4 showing the coordinates of the starter staircase, 8, 8 showing that position inside the stronghold chunk, and Chunk showing the chunk coordinates. The Show angle errors setting is a diagnostic, since it shows how far each measured angle differs from the angle to the predicted stronghold assuming the prediction is correct, which helps you practise eye measurement and acts as a sanity check during a run. Advanced stronghold statistics uses the existence of other strongholds and the fact that an eye points towards the closest one to improve the probability model, and the README says it should stay enabled in almost all cases.

## What else the tool does beyond the core prediction

The additional features list is broader than a calculator. There is blind-coordinate evaluation from the Nether, fossil divine calculations including combined divine and eye measurements, and high-precision boat measurements, all of which are ways of fixing a position that a normal throw cannot. There is an All Advancements mode for Minecraft 1.20 and later, and an OBS overlay that automatically hides when no result is displayed, which matters because a speedrun stream should not show a stale coordinate. There is an HTTP API for integrations, so another tool can query the calculator rather than scraping the screen, plus configurable themes, hotkeys and community translations. The core list adds the rest of the model, with an estimated probability for each candidate location, player measurement error and generation mechanics modelled together, built-in standard deviation calibration, subpixel angle adjustment, and direction and distance updates while travelling.

## The failure mode is moving while you throw

The FAQ answers the question every user eventually asks, why the calculator said it was 100% certain and still missed the stronghold. The answer is that you most likely moved while throwing one of the eyes, because it takes longer than many players expect to come to a complete stop, and your coordinates may appear stationary on the F3 screen while client-server desynchronization still affects the throw. The suggested fixes are to wait before throwing, or to push yourself into a corner between two blocks to stop quickly, which also appears to prevent the same desynchronization problem. The certainty value is an estimate based on the measurements and the configured standard deviation, so incorrect measurements or an unrealistically low standard deviation can make the result overconfident. That is the honest limitation of the whole approach, and it is a good reason to treat the output as a ranked list to check against the world rather than a coordinate to run to blindly.

## Rules, licence and the state of the repository

The legality answer is in the FAQ as well, and it is specific. Stronghold calculators were unbanned for Minecraft speedruns on December 9, 2021, and Ninjabrain Bot is listed as a community speedrunning resource, with the instruction to check the current category rules before submitting a run. That is the one line in this project you should not let go stale, because rules change independently of the tool. The licence is GPLv3, which suits a community project of this kind. On the release side, the versions are 1.5.0 and 1.5.1 from 2024-09-29 and 1.5.2 from 2026-03-24, the last push was on 2026-06-22 and the repository is not archived. The tree is small and readable, with a Maven pom, a src directory, a docs directory, the triangulation.pdf paper, and Eclipse project and settings files, which suggests a single developer working in Eclipse with Maven rather than a team with a build system. It is a small tool, competently built, and the algorithm is published alongside it.

## Conclusion

Ninjabrain Bot fits a speedrunner who wants a ranked list of stronghold candidates rather than a single guess, and who is willing to calibrate their own measurement error, since the probabilities are only as good as the standard deviation you set. It is the wrong choice if you want a fixed answer without any modelling assumptions, because the displayed certainty is an estimate produced by a prior over stronghold rings, chunk snapping and biome rules, and it is a poor fit if you throw eyes while moving, since the README is explicit that a throw made in motion produces a wrong reading no matter how the maths works out. Before you rely on a result, set the standard deviation with the built-in calibration, check the angle errors display, and read the current speedrun.com category rules, because the rules change and the tool is not a substitute for them.

## FAQ

### How do I use the Ninjabrain Bot stronghold calculator?

Download the latest release, run the downloaded JAR, throw an eye of ender, look directly at it and press F3+C, then move to a new position and repeat. The calculator ranks potential stronghold locations and shows how confident it is, and the prediction improves as you add more throws.

### What does the standard deviation setting mean in Ninjabrain Bot?

It describes how accurately you measure eye angles, and a lower value makes the calculator trust your readings more. Typical ranges are 0.050 to 0.200 in Quake Pro, 0.020 to 0.040 at 30 FOV, and 0.005 to 0.010 at 30 FOV with subpixel adjustment, and the advanced settings offer a Calibrate standard deviation entry that estimates the value for you.

### Why did Ninjabrain Bot say 100% certain and still miss the stronghold?

You most likely moved while throwing one of the eyes, since it takes longer than many players expect to come to a complete stop, and your coordinates can look stationary on the F3 screen while client-server desynchronization still affects the throw. Wait before throwing, or push yourself into a corner between two blocks, and remember that a low standard deviation or a bad measurement makes the result overconfident.

## Sources

- [Issues](https://github.com/Ninjabrain1/Ninjabrain-Bot/issues)
- [License: GPL-3.0](https://github.com/Ninjabrain1/Ninjabrain-Bot/blob/main/LICENSE)
- [Ninjabrain1/Ninjabrain-Bot on GitHub](https://github.com/Ninjabrain1/Ninjabrain-Bot)
- [README](https://github.com/Ninjabrain1/Ninjabrain-Bot/blob/main/README.md)
- [Releases](https://github.com/Ninjabrain1/Ninjabrain-Bot/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ninjabrain1-ninjabrain-bot