# doggo: dig's questions asked in a friendlier voice

> doggo is a modern command-line DNS client like dig, written in Go by an author who wanted to extend the Rust tool dog and chose to build his own instead, hence dog plus go. It speaks DoH, DoT, DoQ, DNSCrypt alongside TCP and UDP, outputs color-coded tables or JSON, traces delegation chains iteratively, probes DNS from named countries through Globalping, and configures itself through TOML files and DOGGO environment variables.

**mr-karan/doggo** — :dog: Command-line DNS Client for Humans. Written in Golang

- Repository: https://github.com/mr-karan/doggo
- Website: https://doggo.mrkaran.dev/
- Stars: 4,500 · Forks: 145
- Language: Go
- License: GPL-3.0
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/mr-karan-doggo

## dog, rewritten because Rust

The origin story is refreshingly practical, doggo is totally inspired by dog, the Rust DNS client, whose author wanted to add features but did not know Rust, and found the situation a nice opportunity to experiment with writing a DNS client from scratch in Go, hence the name, dog plus go equals doggo. That genealogy sets expectations correctly, doggo inherits dog's philosophy of human readable DNS output rather than dig compatibility, and it is a from scratch Go implementation rather than a port. The project lives under the mr-karan GitHub account with a web interface and documentation site at doggo.mrkaran.dev, is GPL-3.0 licensed, and its dependency list anchors on miekg's dns library, the standard Go DNS implementation, with quic-go beside it for the QUIC based transports.

## dig's questions, cleaner answers

The basic interactions map one to one from dig vocabulary. A simple lookup is doggo example.com, an MX query against a specific nameserver is doggo MX github.com @9.9.9.9, and reverse lookups take --reverse with an IP and --short for terse output. The difference is the presentation, human readable output in a color-coded and tabular format instead of dig's wall of text, with response time measurement built in and a debug mode for troubleshooting. For scripting, --json emits structured output, and the canonical example pipes it through jq, doggo example.com --json | jq '.responses[0].answers[].address', extracting just the addresses, the shape that makes a DNS tool usable inside larger automation without regex scraping.

## Every encrypted transport, plus HTTP/3

The transport list is the modern full set, DNS over HTTPS, DNS over TLS, DNS over QUIC, plain TCP and UDP, and DNSCrypt, with the nameserver argument choosing among them, a DoH query being as simple as pointing at an HTTPS endpoint like cloudflare-dns.com/dns-query. Beyond DoH itself, --http3 forces DNS over HTTPS over HTTP/3 explicitly, the QUIC based HTTP version, powered by the quic-go library, with the documented caveat that it must be paired with a persistent HTTPS DoH nameserver in configuration. The dnscrypt and dnsstamps dependencies handle the DNSCrypt resolution stamps format. For a diagnostic tool, transport breadth is the feature, since half of modern DNS debugging is determining whether a resolver misbehaves only over one protocol.

## Following the delegation chain

The --trace flag performs iterative delegation tracing, following the chain from the root down through the tiers of nameservers that answer for a name, rather than accepting a recursive resolver's single answer. This is the query dig expresses through a pile of iterative +trace flags and careful reading, turned into one flag and a presented chain, and it answers the class of questions recursive answers hide, whether the breakage is at the registrar, the zone's own servers, or the resolver in between. Combined with the ability to bind queries to a local source address through -b or --source, like dig's -b, and multiple resolver support with customizable query strategies, the tool covers the network vantage point questions that come after the delegation questions.

## Globalping: DNS from Germany and Japan

The most distinctive flag pair is the Globalping integration, doggo example.com --gp-from Germany,Japan --gp-limit 2, which runs the DNS query from probes in the named countries through the Globalping network. Geographic DNS debugging is normally an awkward dance of looking up public resolvers in the right region or spinning up cloud instances, and this collapses it into two flags on the tool already in hand, answering whether a CDN's geo DNS is actually returning the right edges from the places users are. The jsdelivr globalping-go dependency backs it, and the --gp-limit cap keeps probe usage polite.

## TOML, environment variables, and four precedence levels

Configuration persistence is designed rather than bolted on, defaults for any flag can be set in a TOML file at ~/.config/doggo/config.toml, honoring XDG, or ~/.doggo.toml, or through DOGGO_ prefixed environment variables, so repeated flags stop being repeated. The precedence is documented in one line, flag defaults lowest, then config file, then environment variables, then command line flags highest, with --config or DOGGO_CONFIG loading a file from a custom location. The sample configuration shows the shape, strategy, color, a ten second timeout, and the pairing rule worth remembering, a DoH nameserver with http3 true. A config-cli-sample.toml in the repository documents every supported key with its default, and the koanf library under the hood is what makes the layered resolution clean.

## Ten package managers and ARM naming discipline

The installation surface is broad and carefully documented. The easy path is one command:

```shell
curl -fsSL https://raw.githubusercontent.com/mr-karan/doggo/main/install.sh | sh
```

and the first query right after is as short:

```shell
doggo example.com
```

From there, pacman on Arch, eget, emerge on Gentoo, Homebrew, MacPorts, mise, Nix, Scoop and Winget on Windows cover the package managers, go install github.com/mr-karan/doggo/cmd/doggo@latest builds from source, and a Docker image on ghcr runs a query in one line. The binary distribution shows unusual care about 32-bit ARM, Linux ARMv6 and ARMv7 builds ship under explicit armv6 and armv7 names with a compatibility doggo-linux-arm alias, and the BSD variants, FreeBSD, OpenBSD and NetBSD, use the explicit armv7 name while retaining historical arm aliases, the kind of naming precision that only exists because someone got burned by ambiguous ARM tarballs. The goreleaser configuration automates the matrix.

## A web interface, an API, and an Astro docs site

Beyond the CLI, the repository builds a web interface, a separate binary in the web directory served through the chi router with its own Dockerfile and a config-api-sample.toml, deploying the same resolver engine behind HTTP for browser-based querying, and the hosted instance doubles as the project homepage. The documentation site is an Astro project built with yarn through Makefile targets for development, production builds and preview. Shell completions ship for zsh and fish, IDN queries convert to punycode automatically, ndots and search domain configurations are honored for resolver compatibility, and EDNS support runs deep, Client Subnet, NSID, cookies, padding and extended errors, with additional section parsing for glue records. Releases are current, v1.2.1 and v1.3.0 in August 2026 and v1.4.0 on 2026-09-01, the same day as the last push.

## Conclusion

Use doggo as the daily DNS query tool when dig's output style has worn thin and encrypted transports are part of the work, since DoH, DoT, DoQ and DNSCrypt arrive with readable tables and JSON output in one binary, and --trace plus Globalping probes cover the diagnostic questions dig answers awkwardly. Keep dig around for scripts that already parse its format. Before adopting, set a config file so nameservers and strategy persist across invocations, note that HTTP/3 mode requires pairing with a persistent DoH nameserver as the config example warns, and pick the install channel matching your platform, with ten package managers, ARM-specific binary names and a Docker image available.

## FAQ

### What is doggo the DNS tool?

doggo is a modern command-line DNS client like dig, written in Go and inspired by the Rust tool dog, outputting neat, concise, color-coded tables with JSON support. It speaks DoH, DoT, DoQ, DNSCrypt, TCP and UDP, traces delegation chains, and runs queries from chosen countries through Globalping.

### How do you install doggo?

Run the install script with curl -fsSL https://raw.githubusercontent.com/mr-karan/doggo/main/install.sh | sh, or use a package manager, pacman, eget, emerge, Homebrew, MacPorts, mise, Nix, Scoop or Winget, or go install github.com/mr-karan/doggo/cmd/doggo@latest, or pull the Docker image from ghcr.io, with pre-compiled binaries on the releases page including ARM variants.

### How do you configure doggo defaults?

Set defaults in a TOML file at ~/.config/doggo/config.toml or ~/.doggo.toml, or via DOGGO_ prefixed environment variables, with precedence from flag defaults up through config file, environment variables and finally command line flags. Every supported key and default is documented in the repository's config-cli-sample.toml.

## Sources

- [License: GPL-3.0](https://github.com/mr-karan/doggo/blob/main/LICENSE)
- [mr-karan/doggo on GitHub](https://github.com/mr-karan/doggo)
- [Project website](https://doggo.mrkaran.dev/)
- [README](https://github.com/mr-karan/doggo/blob/main/README.md)
- [Releases](https://github.com/mr-karan/doggo/releases)

---

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