ThreadMine vs jstack.review: which online thread dump analyzer should you use?

If you searched for an online thread dump analyzer, jstack.review is a well-earned first stop: it is free, needs no account, and does something genuinely clever — it parses your dump entirely in your browser, so nothing ever leaves your machine. This comparison will not pretend it is a weak tool. The honest question is not "which one is better" but what you need the tool to do — read a dump, or diagnose it.

jstack.review is a viewer: it turns a wall of stack traces into something you can navigate — threads grouped by state, searchable stacks, a clean read. ThreadMine is an analyzer: it reads the same dump and then tells you what is wrongwith it. That difference — reading vs. diagnosing — is the whole comparison, and it decides which one fits your moment.

The 30-second summary

• Choose jstack.review if you want a fast, private, no-account way to read a single dump — the parsing happens in your browser and nothing is uploaded. For a quick eyeball of one dump, it is excellent.
• Choose ThreadMine if you want the dump diagnosed: automatic detection of deadlock, pool exhaustion, thread leak and virtual-thread pinning, an A–F health score, AI root-cause hypotheses, and a timeline across several dumps — with a real free tier and plans from US$ 9/month.
• A tie on the basics: both parse standard jstack/jcmd dumps, both are free to try, and both work in the browser with no install.

Side-by-side comparison

Compiled in July 2026 against the public behavior of jstack.review. If something has changed, the tool itself is the source of truth — this table is a snapshot.

Client-side vs. hosted: the privacy trade-off

This is jstack.review's strongest and most honest advantage, so it goes first. Because it parses the dump in your browser, the file never touches a server — no upload, no account, nothing stored. If your dump is sensitive and company policy says it must not leave the machine, that is a real, decisive reason to reach for it.

ThreadMine analyzes the dump server-side, and that is a deliberate trade: detection, AI hypotheses, health scoring and a searchable history are only possible once the dump has been parsed by an engine that lives somewhere. We take the responsibility that comes with it — dumps are encrypted in transit (TLS 1.3) and at rest, are short-lived, and access is least-privilege (see the security page). But if the requirement is literally "the bytes cannot leave this laptop," jstack.review wins that requirement outright, and we would rather say so than pretend otherwise.

Detection: manual reading vs. automatic

jstack.review shows you the threads clearly and gets out of the way — the interpretation is yours. That is fine when you already know the shape of the problem. But a deadlock across three threads, a pool that is quietly at 100% of its max, a thread count that climbs every snapshot, or a virtual thread pinned to its carrier are exactly the patterns that are hard to spot by eye at 3 a.m.

ThreadMine runs a set of detectors over the parsed dump and names the problems for you: deadlock and lock-contention chains, pool exhaustion, thread leaks, starvation, and virtual-thread pinning (from a standard Java 21+ dump, with no -Djdk.tracePinnedThreads flag). Each finding comes with the evidence and a severity — the difference between "here are your threads" and "here is what is wrong." If you want to understand what that engine is doing under the hood, the thread dump analyzer guide walks through it.

AI and health score

jstack.review does not try to be an AI product, and that focus is part of its appeal. ThreadMine adds two layers on top of detection. First, an A–F health scorethat collapses the whole dump into one honest grade, so you can tell a healthy snapshot from a burning one at a glance. Second, Vein, the built-in AI: root-cause hypotheses ranked by confidence, each grounded in evidence pulled from the dump itself, with a runbook of next steps. Neither exists in a pure viewer — and neither matters if all you wanted was to read the stacks, which is exactly why jstack.review is the right tool for that job.

Multiple dumps: one view vs. a timeline

The standard advice for a hang or a slow leak is to capture 3+ dumps a few seconds apart and compare them (explained in our complete guide to thread dump analysis). jstack.review is built around one dump at a time — you open each snapshot on its own and hold the comparison in your head. ThreadMine stitches N dumps into a timeline and automatically points to the inflection point — the moment the pool started to saturate or the BLOCKED threads began to climb — so the trend does the talking instead of your memory.

When jstack.review is enough

• You just need to read one dump. A single snapshot, a quick look at what each thread is doing — a viewer is the fastest path, and jstack.review is a very good one.
• Privacy is non-negotiable. If the dump cannot leave the machine, client-side parsing is not a nice-to-have — it is the requirement, and jstack.review meets it by design.
• You already know what you are looking for. When you can read a deadlock or a hot lock by eye, you may not need detection, scoring or AI at all.

If none of those describe your moment — you want the dump diagnosed, scored, and tracked across time, or you are staring at an incident without a hypothesis yet — that is where ThreadMine was built to help.

How to test both

Neither tool needs an install, so the honest test costs five minutes: generate a dump (jstack -l <pid>), open it in jstack.review to read the threads, then run the same file through ThreadMine to see the diagnosis. On ThreadMine, your first dump needs no sign-up and comes back with a health score, detected problems, and a root cause. Same dump, two answers — reading vs. diagnosing — and you decide which one your work needs. Plans scale from a real free tier to US$ 9 (Pro) / US$ 29 (Team) per month when you want history and a team.