github.com/go-delve/delve

Delve is the de-facto debugger for Go applications, and for good reason. The DAP (Debug Adapter Protocol) integration works seamlessly with VSCode and other IDEs, making breakpoint debugging straightforward. The CLI interface is powerful once you learn it, though there's a learning curve coming from gdb. The ability to attach to running processes and inspect goroutines with 'goroutines' command has saved me countless hours tracking down race conditions and deadlocks.

From an operations perspective, be aware that running under Delve significantly impacts performance - I've seen 10-50x slowdowns depending on the workload. This makes it impractical for debugging performance issues or anything timing-sensitive. Memory consumption also increases substantially when debugging applications with many goroutines. The API mode (headless server) is useful for remote debugging but requires careful firewall configuration and has no built-in authentication, so never expose it directly to untrusted networks.

Configuration is mostly through command-line flags or IDE launch.json files. Breaking changes between versions have been rare in my experience, though occasional incompatibilities with newer Go versions during betas can be frustrating. Overall, it's an indispensable tool despite its runtime overhead.

Delve is the de-facto debugger for Go, and for good reason. Day-to-day, it provides comprehensive debugging capabilities with excellent support for goroutines, channels, and Go-specific constructs. The API server mode is particularly useful for remote debugging scenarios, though you need to be mindful of the performance impact when attaching to running processes.

From an operations perspective, Delve adds significant memory overhead when attached - expect 2-3x memory usage in the debugged process. The `--check-go-version=false` flag is often necessary in containerized environments where Go versions don't match. Timeout behavior during attach operations can be frustrating with large heaps; the default 10-second timeout is often insufficient for production services under load.

Configuration through command-line flags is flexible, but there's no config file support which makes scripting repetitive debugging sessions cumbersome. The headless mode works reliably for CI/CD integration, though connection management requires explicit cleanup to avoid resource leaks when automating debug sessions.

Delve has become my daily driver for Go debugging and honestly transformed how I work with Go code. The CLI interface is intuitive once you learn the basic commands (break, continue, print, next, step), and the learning curve is gentle - I was productive within an hour. The `dlv debug` command just works for most projects, and `dlv attach` for running processes has saved me countless times in production troubleshooting.

What really stands out is the quality of the debugging experience itself. Goroutine inspection with `goroutines` and `goroutine <id>` commands makes concurrent debugging actually manageable. Variable inspection handles complex types well, and you can evaluate expressions on the fly. The error messages are clear when things go wrong - like when debug symbols are stripped or when you're trying to debug optimized code.

IDE integration (VSCode, GoLand) is seamless through the DAP protocol, which means you get the same reliable debugging whether you're in the terminal or your editor. The community is responsive on GitHub issues, and the documentation covers both basic usage and advanced scenarios like remote debugging. Stack Overflow has good coverage for common pitfalls.