Implements a deep pretty printer for Go data structures to aid in debugging
Go Shell
Latest commit 6d21280 Sep 7, 2016 @davecgh Deprecate "disableunsafe" tag in favor of "safe".
This adds a new build tag named "safe" which serves the exact same
purpose as the current "disableunsafe" tag.  This is being done, as
recommended by @shurcooL, since it is emerging as the standard way to do
it in several high profile packages, it mirrors the "unsafe" package
nicely, it is shorter, and users generally seem to prefer it.

However, to avoid breaking existing infrastructure, the disableunsafe
tag is still available and simply is being deprecated.


Build Status Coverage Status

Go-spew implements a deep pretty printer for Go data structures to aid in debugging. A comprehensive suite of tests with 100% test coverage is provided to ensure proper functionality. See test_coverage.txt for the gocov coverage report. Go-spew is licensed under the liberal ISC license, so it may be used in open source or commercial projects.

If you're interested in reading about how this package came to life and some of the challenges involved in providing a deep pretty printer, there is a blog post about it here.



Full go doc style documentation for the project can be viewed online without installing this package by using the excellent GoDoc site here:

You can also view the documentation locally once the package is installed with the godoc tool by running godoc -http=":6060" and pointing your browser to http://localhost:6060/pkg/


$ go get -u

Quick Start

Add this import line to the file you're working in:

import ""

To dump a variable with full newlines, indentation, type, and pointer information use Dump, Fdump, or Sdump:

spew.Dump(myVar1, myVar2, ...)
spew.Fdump(someWriter, myVar1, myVar2, ...)
str := spew.Sdump(myVar1, myVar2, ...)

Alternatively, if you would prefer to use format strings with a compacted inline printing style, use the convenience wrappers Printf, Fprintf, etc with %v (most compact), %+v (adds pointer addresses), %#v (adds types), or %#+v (adds types and pointer addresses):

spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)

Debugging a Web Application Example

Here is an example of how you can use spew.Sdump() to help debug a web application. Please be sure to wrap your output using the html.EscapeString() function for safety reasons. You should also only use this debugging technique in a development environment, never in production.

package main

import (


func handler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    fmt.Fprintf(w, "Hi there, %s!", r.URL.Path[1:])
    fmt.Fprintf(w, "<!--\n" + html.EscapeString(spew.Sdump(w)) + "\n-->")

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)

Sample Dump Output

(main.Foo) {
 unexportedField: (*main.Bar)(0xf84002e210)({
  flag: (main.Flag) flagTwo,
  data: (uintptr) <nil>
 ExportedField: (map[interface {}]interface {}) {
  (string) "one": (bool) true
([]uint8) {
 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
 00000020  31 32                                             |12|

Sample Formatter Output

Double pointer to a uint8:

      %v: <**>5
     %+v: <**>(0xf8400420d0->0xf8400420c8)5
     %#v: (**uint8)5
    %#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5

Pointer to circular struct with a uint8 field and a pointer to itself:

      %v: <*>{1 <*><shown>}
     %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
     %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
    %#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}

Configuration Options

Configuration of spew is handled by fields in the ConfigState type. For convenience, all of the top-level functions use a global state available via the spew.Config global.

It is also possible to create a ConfigState instance that provides methods equivalent to the top-level functions. This allows concurrent configuration options. See the ConfigState documentation for more details.

* Indent
    String to use for each indentation level for Dump functions.
    It is a single space by default.  A popular alternative is "\t".

* MaxDepth
    Maximum number of levels to descend into nested data structures.
    There is no limit by default.

* DisableMethods
    Disables invocation of error and Stringer interface methods.
    Method invocation is enabled by default.

* DisablePointerMethods
    Disables invocation of error and Stringer interface methods on types
    which only accept pointer receivers from non-pointer variables.  This option
    relies on access to the unsafe package, so it will not have any effect when
    running in environments without access to the unsafe package such as Google
    App Engine or with the "safe" build tag specified.
    Pointer method invocation is enabled by default.

* ContinueOnMethod
    Enables recursion into types after invoking error and Stringer interface
    methods. Recursion after method invocation is disabled by default.

* SortKeys
    Specifies map keys should be sorted before being printed. Use
    this to have a more deterministic, diffable output.  Note that
    only native types (bool, int, uint, floats, uintptr and string)
    and types which implement error or Stringer interfaces are supported,
    with other types sorted according to the reflect.Value.String() output
    which guarantees display stability.  Natural map order is used by

* SpewKeys
    SpewKeys specifies that, as a last resort attempt, map keys should be
    spewed to strings and sorted by those strings.  This is only considered
    if SortKeys is true.

Unsafe Package Dependency

This package relies on the unsafe package to perform some of the more advanced features, however it also supports a "limited" mode which allows it to work in environments where the unsafe package is not available. By default, it will operate in this mode on Google App Engine and when compiled with GopherJS. The "safe" build tag may also be specified to force the package to build without using the unsafe package.


Go-spew is licensed under the liberal ISC License.