explaingit

maruel/panicparse

Analysis updated 2026-07-03

3,714GoAudience · developerComplexity · 2/5Setup · easy

TLDR

A command-line tool that makes Go crash dumps readable by grouping identical goroutines and cutting output length by more than half, plus an embeddable library for live goroutine inspection in running servers.

Mindmap

mindmap
  root((panicparse))
    What it does
      Groups identical goroutines
      Cuts output by 50 percent
      Labels memory pointers
      Sorts stdlib to bottom
    How to use
      Pipe crash output
      Read from file
      Embed HTTP endpoint
    Tech Stack
      Go
    Audience
      Go developers
      Server operators
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Pipe a crashing Go program or test run through panicparse to get a compact, grouped stack trace instead of thousands of repeated lines.

USE CASE 2

Embed the library into a Go HTTP server to expose a live endpoint showing all goroutines in a readable format for production debugging.

USE CASE 3

Save a goroutine dump to a file and pass it to panicparse to diagnose a deadlock without needing a live crash.

What is it built with?

Go

How does it compare?

maruel/panicparseolivia-ai/olivianikoksr/notify
Stars3,7143,7193,721
LanguageGoGoGo
Setup difficultyeasyeasyeasy
Complexity2/53/52/5
Audiencedeveloperdeveloperdeveloper

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · easy Time to first run · 5min

In plain English

Panicparse is a command-line tool for Go developers that makes crash output readable. When a Go program crashes or deadlocks, the runtime prints a stack trace that can be hundreds or thousands of lines long, especially in programs that run many goroutines at the same time. Goroutines are Go's way of doing multiple things concurrently, and a busy server might have thousands of them running when it crashes. The resulting dump is technically complete but extremely hard to read. Parseparse processes that raw crash output and reformats it into something much more compact and organized. It groups goroutines that share the same stack trace so identical ones appear once with a count, rather than repeated hundreds of times. It pushes goroutines that are only running standard library code to the bottom of the output so the developer can focus on their own application code. It replaces raw memory addresses with shorter identifier labels so pointers are easier to follow. The result is described as more than 50% more compact than the original while being more readable. Usage is straightforward: you pipe the output of your Go program or test run through the tool on the command line. The exact pipe syntax varies slightly depending on whether you are on Linux, macOS, or Windows, and which shell you are using, and the README covers all the common cases. You can also dump a crash to a file and pass that file to the tool directly. Beyond the command-line formatter, the project includes a library component that can be embedded into a running Go HTTP server. This lets you add an endpoint to your server that shows a live snapshot of all goroutines in a formatted, readable layout, which is useful for diagnosing slowdowns or deadlocks in production without needing a crash dump.

Copy-paste prompts

Prompt 1
Using panicparse, show me how to pipe a panicking Go test run on macOS so I get a grouped, compact goroutine report.
Prompt 2
How do I add panicparse's library to my Go HTTP server to create a /debug/goroutines endpoint that shows a formatted live goroutine snapshot?
Prompt 3
I have a crash dump file from a Go server deadlock. Walk me through running panicparse on it to identify the stuck goroutines.
Prompt 4
What do the short identifier labels that panicparse uses to replace raw memory addresses mean, and how do I read them?

Frequently asked questions

What is panicparse?

A command-line tool that makes Go crash dumps readable by grouping identical goroutines and cutting output length by more than half, plus an embeddable library for live goroutine inspection in running servers.

What language is panicparse written in?

Mainly Go. The stack also includes Go.

How hard is panicparse to set up?

Setup difficulty is rated easy, with roughly 5min to a first successful run.

Who is panicparse for?

Mainly developer.

Open on GitHub → Explain another repo

This repo across BitVibe Labs

Scan in gitsafehub Deploy in gitdeployhub maruel on gitmyhub

Verify against the repo before relying on details.