diff --git a/.golangci.yml b/.golangci.yml
index 8cb08f7..0430f52 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,9 +1,364 @@
+# This file contains all available configuration options
+# with their default values.
+
+# options for analysis running
+run:
+  # default concurrency is a available CPU number
+  # concurrency: 4
+
+  # timeout for analysis, e.g. 30s, 5m, default is 1m
+  timeout: 30m
+
+  # exit code when at least one issue was found, default is 1
+  issues-exit-code: 1
+
+  # include test files or not, default is true
+  tests: true
+
+  # list of build tags, all linters use it. Default is empty list.
+  # build-tags:
+  #   - mytag
+
+  # which dirs to skip: issues from them won't be reported;
+  # can use regexp here: generated.*, regexp is applied on full path;
+  # default value is empty list, but default dirs are skipped independently
+  # from this option's value (see skip-dirs-use-default).
+  # skip-dirs:
+  #   - src/external_libs
+  #   - autogenerated_by_my_lib
+
+  # default is true. Enables skipping of directories:
+  #   vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
+  skip-dirs-use-default: true
+
+  # which files to skip: they will be analyzed, but issues from them
+  # won't be reported. Default value is empty list, but there is
+  # no need to include all autogenerated files, we confidently recognize
+  # autogenerated files. If it's not please let us know.
+  skip-files:
+      - ".*/inventory_easyjson.go"
+  #   - ".*\\.my\\.go$"
+  #   - lib/bad.go
+
+  # by default isn't set. If set we pass it to "go list -mod={option}". From "go help modules":
+  # If invoked with -mod=readonly, the go command is disallowed from the implicit
+  # automatic updating of go.mod described above. Instead, it fails when any changes
+  # to go.mod are needed. This setting is most useful to check that go.mod does
+  # not need updates, such as in a continuous integration and testing system.
+  # If invoked with -mod=vendor, the go command assumes that the vendor
+  # directory holds the correct copies of dependencies and ignores
+  # the dependency descriptions in go.mod.
+  # modules-download-mode: readonly|release|vendor
+
+# output configuration options
+output:
+  # colored-line-number|line-number|json|tab|checkstyle|code-climate, default is "colored-line-number"
+  format: line-number
+
+  # print lines of code with issue, default is true
+  print-issued-lines: true
+
+  # print linter name in the end of issue text, default is true
+  print-linter-name: true
+
+# all available settings of specific linters
+linters-settings:
+  errcheck:
+    # report about not checking of errors in type assetions: `a := b.(MyStruct)`;
+    # default is false: such cases aren't reported by default.
+    check-type-assertions: false
+
+    # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`;
+    # default is false: such cases aren't reported by default.
+    check-blank: false
+
+    # [deprecated] comma-separated list of pairs of the form pkg:regex
+    # the regex is used to ignore names within pkg. (default "fmt:.*").
+    # see https://github.com/kisielk/errcheck#the-deprecated-method for details
+    # ignore: fmt:.*,io/ioutil:^Read.*
+
+    # path to a file containing a list of functions to exclude from checking
+    # see https://github.com/kisielk/errcheck#excluding-functions for details
+    # exclude: /path/to/file.txt
+
+  # Disable error checking, as errorcheck detects more errors and is more configurable.
+
+  funlen:
+    lines: 60
+    statements: 40
+
+  govet:
+    # report about shadowed variables
+    check-shadowing: true
+
+    # settings per analyzer
+    settings:
+      printf: # analyzer name, run `go tool vet help` to see all analyzers
+        funcs: # run `go tool vet help printf` to see available settings for `printf` analyzer
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Infof
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Warnf
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Errorf
+          - (github.com/golangci/golangci-lint/pkg/logutils.Log).Fatalf
+
+    # enable or disable analyzers by name
+    # enable:
+    #   - atomicalign
+    # enable-all: false
+    # disable:
+    #   - shadow
+    # disable-all: false
+  gofmt:
+    # simplify code: gofmt with `-s` option, true by default
+    simplify: true
+  goimports: {}
+    # put imports beginning with prefix after 3rd-party packages;
+    # it's a comma-separated list of prefixes
+    # local-prefixes: github.com/org/project
+  gocyclo:
+    # minimal code complexity to report, 30 by default (but we recommend 10-20)
+    min-complexity: 20
+  gocognit:
+    # minimal code complexity to report, 30 by default (but we recommend 10-20)
+    min-complexity: 20
+  maligned:
+    # print struct with more effective memory layout or not, false by default
+    suggest-new: true
+  dupl:
+    # tokens count to trigger issue, 150 by default
+    threshold: 100
+  goconst:
+    # minimal length of string constant, 3 by default
+    min-len: 3
+    # minimal occurrences count to trigger, 3 by default
+    min-occurrences: 3
+  depguard:
+    rules:
+      main:
+        files:
+          - "$all"
+          - "!$test"
+        deny:
+          - pkg: "log$"
+            desc: "Use log/slog so we can always do structured logging, via the logger"
+          - pkg: "github.com/rs/zerolog/log"
+            desc: "Use log/slog so we can always do structured logging, via the logger"
+        allow:
+          - '$gostd'
+          - "github.com/spf13/cobra"
+          - "github.com/spf13/viper"
+          - "github.com/spf13/pflag"
+          - "github.com/mitchellh/go-homedir"
+          - "github.com/drewstinnett/gout/v2/formats"
+      tests:
+        files:
+          - "$test"
+        allow:
+          - '$gostd'
+          - "github.com/stretchr/testify"
+          - "github.com/stretchr/testify/require"
+          - "github.com/drewstinnett/gout/v2/formats"
+          - _ "github.com/drewstinnett/gout/v2/formats/builtin"
+  # depguard:
+  #   list-type: blacklist
+  #   include-go-root: false
+  #   packages:
+  #     - github.com/sirupsen/logrus
+  #   packages-with-error-messages:
+  #     # specify an error message to output when a blacklisted package is used
+  #     github.com/sirupsen/logrus: "logging is allowed only by logutils.Log"
+  misspell:
+    # Correct spellings using locale preferences for US or UK.
+    # Default is to use a neutral variety of English.
+    # Setting locale to US will correct the British spelling of 'colour' to 'color'.
+    locale: US
+    ignore-words:
+      - GitLab
+  lll:
+    # max line length, lines longer will be reported. Default is 120.
+    # '\t' is counted as 1 character by default, and can be changed with the tab-width option
+    line-length: 120
+    # tab width in spaces. Default to 1.
+    tab-width: 1
+  # unused:
+    # treat code as a program (not a library) and report unused exported identifiers; default is false.
+    # XXX: if you enable this setting, unused will report a lot of false-positives in text editors:
+    # if it's called for subdir of a project it can't find funcs usages. All text editor integrations
+    # with golangci-lint call it on a directory with the changed file.
+    # check-exported: false
+  unparam:
+    # Inspect exported functions, default is false. Set to true if no external program/library imports your code.
+    # XXX: if you enable this setting, unparam will report a lot of false-positives in text editors:
+    # if it's called for subdir of a project it can't find external interfaces. All text editor integrations
+    # with golangci-lint call it on a directory with the changed file.
+    check-exported: false
+  nakedret:
+    # make an issue if func has more lines of code than this setting and it has naked returns; default is 30
+    max-func-lines: 30
+  prealloc:
+    # XXX: we don't recommend using this linter before doing performance profiling.
+    # For most programs usage of prealloc will be a premature optimization.
+
+    # Report preallocation suggestions only on simple loops that have no returns/breaks/continues/gotos in them.
+    # True by default.
+    simple: true
+    range-loops: true # Report preallocation suggestions on range loops, true by default
+    for-loops: false # Report preallocation suggestions on for loops, false by default
+  gocritic:
+    # Which checks should be enabled; can't be combined with 'disabled-checks';
+    # See https://go-critic.github.io/overview#checks-overview
+    # To check which checks are enabled run `GL_DEBUG=gocritic golangci-lint run`
+    # By default list of stable checks is used.
+    # enabled-checks:
+    #   - rangeValCopy
+
+    # Which checks should be disabled; can't be combined with 'enabled-checks'; default is empty
+    # disabled-checks:
+    #   - regexpMust
+
+    # Enable multiple checks by tags, run `GL_DEBUG=gocritic golangci-lint run` to see all tags and checks.
+    # Empty list by default. See https://github.com/go-critic/go-critic#usage -> section "Tags".
+    # enabled-tags:
+    #   - performance
+
+    settings: # settings passed to gocritic
+      captLocal: # must be valid enabled check name
+        paramsOnly: true
+    # rangeValCopy:
+    #   sizeThreshold: 32
+  godox:
+    # report any comments starting with keywords, this is useful for TODO or FIXME comments that
+    # might be left in the code accidentally and should be resolved before merging
+    keywords: # default keywords are TODO, BUG, and FIXME, these can be overwritten by this setting
+      - TODO
+      - BUG
+      - FIXME
+      - NOTE
+      - OPTIMIZE # marks code that should be optimized before merging
+      - HACK # marks hack-arounds that should be removed before merging
+  dogsled:
+    # checks assignments with too many blank identifiers; default is 2
+    max-blank-identifiers: 2
+
+  whitespace:
+    multi-if: false   # Enforces newlines (or comments) after every multi-line if statement
+    multi-func: false # Enforces newlines (or comments) after every multi-line function signature
+  wsl:
+    # If true append is only allowed to be cuddled if appending value is
+    # matching variables, fields or types on line above. Default is true.
+    strict-append: true
+    # Allow calls and assignments to be cuddled as long as the lines have any
+    # matching variables, fields or types. Default is true.
+    allow-assign-and-call: true
+    # Allow multiline assignments to be cuddled. Default is true.
+    allow-multiline-assign: true
+    # Allow declarations (var) to be cuddled.
+    allow-cuddle-declarations: false
+    # Allow trailing comments in ending of blocks
+    allow-trailing-comment: false
+    # Force newlines in end of case at this limit (0 = never).
+    force-case-trailing-whitespace: 0
+
 linters:
+  # please, do not use `enable-all`: it's deprecated and will be removed soon.
+  # inverted configuration with `enable-all` and `disable` is not scalable during updates of golangci-lint
+  disable-all: true
   enable:
-    - thelper
-    - gofumpt
-    - tparallel
+    - bodyclose
+    - depguard
+    - dogsled
+    - dupl
+    - errcheck
+    - funlen
+    - gocognit
+    - goconst
+    - gocritic
+    - godox
+    - gofmt
+    - goimports
+    - revive
+    - gosec
+    - gosimple
+    - govet
+    - ineffassign
+    - misspell
+    - nakedret
+    - exportloopref
+    - staticcheck
+    - stylecheck
+    - typecheck
     - unconvert
     - unparam
-    - wastedassign
-    - revive
+    - unused
+    - whitespace
+  # don't enable:
+  # - deadcode
+  # - gochecknoglobals
+  # - gochecknoinits
+  # - gocyclo
+  # - lll
+  # - maligned
+  # - prealloc
+  # - varcheck
+
+issues:
+  # List of regexps of issue texts to exclude, empty list by default.
+  # But independently from this option we use default exclude patterns,
+  # it can be disabled by `exclude-use-default: false`. To list all
+  # excluded by default patterns execute `golangci-lint run --help`
+  # exclude:
+  #   - abcdef
+
+  # Excluding configuration per-path, per-linter, per-text and per-source
+  exclude-rules:
+    # Exclude some linters from running on tests files.
+    - path: _test\.go
+      linters:
+        - gocyclo
+        - errcheck
+        - dupl
+        - gosec
+        - funlen
+
+    # Exclude known linters from partially hard-vendored code,
+    # which is impossible to exclude via "nolint" comments.
+    # - path: internal/hmac/
+    #   text: "weak cryptographic primitive"
+    #   linters:
+    #     - gosec
+
+    # Exclude some staticcheck messages
+    # - linters:
+    #     - staticcheck
+    #   text: "SA9003:"
+
+    # Exclude lll issues for long lines with go:generate
+    - linters:
+        - lll
+      source: "^//go:generate "
+
+  # Independently from option `exclude` we use default exclude patterns,
+  # it can be disabled by this option. To list all
+  # excluded by default patterns execute `golangci-lint run --help`.
+  # Default value for this option is true.
+  exclude-use-default: false
+
+  # Maximum issues count per one linter. Set to 0 to disable. Default is 50.
+  max-issues-per-linter: 0
+
+  # Maximum count of issues with the same text. Set to 0 to disable. Default is 3.
+  max-same-issues: 0
+
+  # Show only new issues: if there are unstaged changes or untracked files,
+  # only those changes are analyzed, else only changes in HEAD~ are analyzed.
+  # It's a super-useful option for integration of golangci-lint into existing
+  # large codebase. It's not practical to fix all existing issues at the moment
+  # of integration: much better don't allow issues in new code.
+  # Default is false.
+  new: false
+
+  # Show only new issues created after git revision `REV`
+  # This should be passed as flag during individual CI jobs.
+  # new-from-rev: REV
+
+  # Show only new issues created in git patch with set file path.
+  # new-from-patch: path/to/patch/file
diff --git a/_examples/gotemplate/main.go b/_examples/gotemplate/main.go
index fafc325..14f320a 100644
--- a/_examples/gotemplate/main.go
+++ b/_examples/gotemplate/main.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	gout "github.com/drewstinnett/gout/v2"
-	"github.com/drewstinnett/gout/v2/config"
 	"github.com/drewstinnett/gout/v2/formats/gotemplate"
 )
 
@@ -24,9 +23,7 @@ func main() {
 	}
 	g := gout.New()
 	g.SetFormatter(gotemplate.Formatter{
-		Opts: config.FormatterOpts{
-			"template": "{{ range . }}{{ .FirstName }} {{ .LastName }} is {{ .Age }} years old\n{{ end }}",
-		},
+		Template: "{{ range . }}{{ .FirstName }} {{ .LastName }} is {{ .Age }} years old\n{{ end }}",
 	})
 	//"template": "{{ range . }}{{ .FirstName }} {{ .LastName }} is {{ .Age }} years old\n{{ end }}",
 	fmt.Printf("# Format: gotemplate\n## People\n")
diff --git a/config/config.go b/config/config.go
deleted file mode 100644
index f6ec8c1..0000000
--- a/config/config.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package config
-
-// type FormatterOpts map[string]interface{}
-type FormatterOpts map[string]interface{}
-
-/*
-type FormatterOptsV2 interface {
-	Set(string, interface{}) error
-	Get(string) (interface{}, error)
-}
-*/
diff --git a/doc/README.md b/doc/README.md
deleted file mode 100644
index 613cb64..0000000
--- a/doc/README.md
+++ /dev/null
@@ -1,64 +0,0 @@
-<!-- Code generated by gomarkdoc. DO NOT EDIT -->
-
-# formatter
-
-```go
-import "github.com/drewstinnett/gout/formatter"
-```
-
-## Index
-
-- [func GenericUnmarshal(data interface{}) ([]map[string]interface{}, error)](<#func-genericunmarshal>)
-- [func GetFormats() []string](<#func-getformats>)
-- [func OutputData(data interface{}, config *Config) ([]byte, error)](<#func-outputdata>)
-- [func StringInSlice(a string, list []string) bool](<#func-stringinslice>)
-- [type Config](<#type-config>)
-
-
-## func GenericUnmarshal
-
-```go
-func GenericUnmarshal(data interface{}) ([]map[string]interface{}, error)
-```
-
-GenericUnmarshal Given an arbitrary piece of data\, return a slice of json data
-
-## func GetFormats
-
-```go
-func GetFormats() []string
-```
-
-GetFormats Return a list of formats available in formatters\. Useful if you need to check what formatters are available in a standardized way
-
-## func OutputData
-
-```go
-func OutputData(data interface{}, config *Config) ([]byte, error)
-```
-
-OutputData Main function to return the data we will be printing to the screen\. This is where the magic happens\!
-
-## func StringInSlice
-
-```go
-func StringInSlice(a string, list []string) bool
-```
-
-StringInSlice Check if a slice for a string
-
-## type Config
-
-Config Structure to pass to formatters\.  Should include enough config to do the output\. You must set the Format here to something like yaml\, json\, plain\, or any other value returned by the GetFormats function
-
-```go
-type Config struct {
-    Format      string
-    LimitFields []string
-    Template    string
-}
-```
-
-
-
-Generated by [gomarkdoc](<https://github.com/princjef/gomarkdoc>)
diff --git a/formats/gotemplate/gotemplate.go b/formats/gotemplate/gotemplate.go
index 0e1a400..3024178 100644
--- a/formats/gotemplate/gotemplate.go
+++ b/formats/gotemplate/gotemplate.go
@@ -1,3 +1,6 @@
+/*
+Package gotemplate provides a way to template output as a plugin to Gout
+*/
 package gotemplate
 
 import (
@@ -5,27 +8,22 @@ import (
 	"errors"
 	"text/template"
 
-	"github.com/drewstinnett/gout/v2/config"
 	"github.com/drewstinnett/gout/v2/formats"
 )
 
+// Formatter is the base object for the gotemplate object
 type Formatter struct {
-	// Template string
-	Opts config.FormatterOpts
+	Template string
+	// Opts config.FormatterOpts
 }
 
-// type TemplateField struct{}
+// Format satisfies the formats.Format interface
 func (w Formatter) Format(v interface{}) ([]byte, error) {
-	var tp string
-	if t, ok := w.Opts["template"]; !ok {
-		tp = `{{ printf "%+v" . }}`
-	} else {
-		if tp, ok = t.(string); !ok {
-			return nil, errors.New("Found a template option, but it's not a string")
-		}
+	if w.Template == "" {
+		return nil, errors.New("no Template set for gotemplate")
 	}
 	var doc bytes.Buffer
-	tmpl, err := template.New("item").Parse(tp)
+	tmpl, err := template.New("item").Parse(w.Template)
 	if err != nil {
 		return nil, err
 	}
@@ -38,6 +36,8 @@ func (w Formatter) Format(v interface{}) ([]byte, error) {
 
 func init() {
 	formats.Add("gotemplate", func() formats.Formatter {
-		return &Formatter{}
+		return &Formatter{
+			Template: `{{ printf "%+v" . }}`,
+		}
 	})
 }
diff --git a/formats/gotemplate/gotemplate_test.go b/formats/gotemplate/gotemplate_test.go
index bfd054c..0c2e908 100644
--- a/formats/gotemplate/gotemplate_test.go
+++ b/formats/gotemplate/gotemplate_test.go
@@ -3,25 +3,38 @@ package gotemplate
 import (
 	"testing"
 
-	"github.com/drewstinnett/gout/v2/config"
 	"github.com/stretchr/testify/require"
 )
 
 func TestGTOFormatterFormat(t *testing.T) {
-	f := Formatter{}
-	v := struct {
+	f := Formatter{
+		Template: `{{ printf "%+v" . }}`,
+	}
+	got, err := f.Format(struct {
 		Title string
 		Year  int
 	}{
 		Title: "Ghostbusters",
 		Year:  1985,
-	}
-	got, err := f.Format(v)
+	})
 	require.NoError(t, err)
 	require.NotNil(t, got)
 	require.Equal(t, "{Title:Ghostbusters Year:1985}", string(got))
 }
 
+func TestEmptyTemplate(t *testing.T) {
+	f := Formatter{}
+	got, err := f.Format(struct {
+		Title string
+		Year  int
+	}{
+		Title: "Ghostbusters",
+		Year:  1985,
+	})
+	require.EqualError(t, err, "no Template set for gotemplate")
+	require.Nil(t, got)
+}
+
 func TestGTOFormatter(t *testing.T) {
 	v := struct {
 		Title string
@@ -31,9 +44,7 @@ func TestGTOFormatter(t *testing.T) {
 		Year:  1985,
 	}
 	f := Formatter{
-		Opts: map[string]interface{}{
-			"template": "{{ .Title }}",
-		},
+		Template: "{{ .Title }}",
 	}
 	got, err := f.Format(v)
 	require.NoError(t, err)
@@ -50,9 +61,7 @@ func TestGTOFormatterTemplateError(t *testing.T) {
 		Year:  1985,
 	}
 	f := Formatter{
-		Opts: map[string]interface{}{
-			"template": "{{ .NotExistingField }}",
-		},
+		Template: "{{ .NotExistingField }}",
 	}
 	got, err := f.Format(v)
 	require.Error(t, err)
@@ -74,9 +83,7 @@ func TestGTOFormatterMultiVal(t *testing.T) {
 		},
 	}
 	f := Formatter{
-		Opts: map[string]interface{}{
-			"template": "{{ range . }}{{ .Title }}\n{{ end }}",
-		},
+		Template: "{{ range . }}{{ .Title }}\n{{ end }}",
 	}
 	got, err := f.Format(v)
 	require.NoError(t, err)
@@ -93,9 +100,7 @@ func TestGTOWithOptsFormatter(t *testing.T) {
 		Year:  1985,
 	}
 	f := Formatter{
-		Opts: config.FormatterOpts{
-			"template": "{{ .Title }}",
-		},
+		Template: "{{ .Title }}",
 	}
 	got, err := f.Format(v)
 	require.NoError(t, err)
@@ -131,9 +136,7 @@ func TestFormatWithContext(t *testing.T) {
 		Year:  1985,
 	}
 	f := Formatter{
-		Opts: config.FormatterOpts{
-			"template": "{{ .Title }}",
-		},
+		Template: "{{ .Title }}",
 	}
 	got, err := f.Format(v)
 	require.NoError(t, err)
diff --git a/formats/json/json.go b/formats/json/json.go
index 2218a07..dae838d 100644
--- a/formats/json/json.go
+++ b/formats/json/json.go
@@ -1,38 +1,26 @@
+/*
+Package json provides a json output plugin for Gout
+*/
 package json
 
 import (
-	"context"
 	ujson "encoding/json"
 
 	"github.com/drewstinnett/gout/v2/formats"
 )
 
-type Formatter struct {
-	ctx context.Context
-}
-
-type IndentField struct{}
+// Formatter holds the base json stuff
+type Formatter struct{}
 
+// Format satiesfiles the formats.Formatter interface
 func (w Formatter) Format(v interface{}) ([]byte, error) {
 	var i any
-	if w.ctx != nil {
-		i = w.ctx.Value(IndentField{})
-	}
 	if i == nil {
 		return ujson.Marshal(v)
 	}
 	return ujson.MarshalIndent(v, "", "  ")
 }
 
-func (w Formatter) FormatWithContext(ctx context.Context, v interface{}) ([]byte, error) {
-	return w.withContext(ctx).Format(v)
-}
-
-func (w *Formatter) withContext(ctx context.Context) *Formatter {
-	w.ctx = ctx
-	return w
-}
-
 func init() {
 	formats.Add("json", func() formats.Formatter {
 		return &Formatter{}
diff --git a/formats/json/json_test.go b/formats/json/json_test.go
index 0d6f9d3..a934d01 100644
--- a/formats/json/json_test.go
+++ b/formats/json/json_test.go
@@ -1,7 +1,6 @@
 package json
 
 import (
-	"context"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -18,16 +17,3 @@ func TestJSONFormatter(t *testing.T) {
 	require.IsType(t, []byte{}, got)
 	require.Equal(t, string(`{"Foo":"bar"}`), string(got))
 }
-
-func TestJSONFormatterWithOpts(t *testing.T) {
-	f := Formatter{}
-	ctx := context.WithValue(context.Background(), IndentField{}, "yes")
-	got, err := f.FormatWithContext(ctx, struct {
-		Foo string
-	}{
-		Foo: "bar",
-	})
-	require.NoError(t, err)
-	require.IsType(t, []byte{}, got)
-	require.Equal(t, string("{\n  \"Foo\": \"bar\"\n}"), string(got))
-}
diff --git a/formats/plain/plain.go b/formats/plain/plain.go
index 23d62fb..54f31d0 100644
--- a/formats/plain/plain.go
+++ b/formats/plain/plain.go
@@ -1,3 +1,6 @@
+/*
+Package plain just prints the variable as %+v
+*/
 package plain
 
 import (
@@ -6,8 +9,10 @@ import (
 	"github.com/drewstinnett/gout/v2/formats"
 )
 
+// Formatter is the base struct for the plain plugin
 type Formatter struct{}
 
+// Format satisfies the formats.Formatter interface
 func (w Formatter) Format(v interface{}) ([]byte, error) {
 	return []byte(fmt.Sprintf("%+v\n", v)), nil
 }
diff --git a/formats/registry.go b/formats/registry.go
index 654e1f3..d51c902 100644
--- a/formats/registry.go
+++ b/formats/registry.go
@@ -1,11 +1,16 @@
+/*
+Package formats provides some base extractions for format plugins
+*/
 package formats
 
 import (
 	"sort"
 )
 
+// Creator is a generator for new formatter instances
 type Creator func() Formatter
 
+// Formats defines a map of labels to Creators
 var Formats = map[string]Creator{}
 
 // Add a new format creator
@@ -15,7 +20,7 @@ func Add(name string, creator Creator) {
 
 // Names returns a slice of the names of the formatters
 func Names() []string {
-	ret := []string{}
+	ret := make([]string, 0, len(Formats))
 	for k := range Formats {
 		ret = append(ret, k)
 	}
diff --git a/formats/xml/xml.go b/formats/xml/xml.go
index b26f5af..6ed7f72 100644
--- a/formats/xml/xml.go
+++ b/formats/xml/xml.go
@@ -1,3 +1,6 @@
+/*
+Package xml provides an XML plugin for Gout
+*/
 package xml
 
 import (
@@ -6,8 +9,10 @@ import (
 	"github.com/drewstinnett/gout/v2/formats"
 )
 
+// Formatter is the base struct for the xml plugin
 type Formatter struct{}
 
+// Format satisfies the formats.Formatter interface
 func (w Formatter) Format(v interface{}) ([]byte, error) {
 	return uxml.Marshal(v)
 }
diff --git a/formats/yaml/yaml.go b/formats/yaml/yaml.go
index 8099519..28ea159 100644
--- a/formats/yaml/yaml.go
+++ b/formats/yaml/yaml.go
@@ -1,3 +1,6 @@
+/*
+Package yaml provides the yaml plugin for Gout
+*/
 package yaml
 
 import (
@@ -5,8 +8,10 @@ import (
 	uyaml "gopkg.in/yaml.v3"
 )
 
+// Formatter is the base structure that holds the yaml plugin stuff
 type Formatter struct{}
 
+// Format satisfies the formats.Formatter interface
 func (w Formatter) Format(v interface{}) ([]byte, error) {
 	return uyaml.Marshal(v)
 }
diff --git a/formatters.go b/formatters.go
deleted file mode 100644
index c8518d7..0000000
--- a/formatters.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package gout
-
-// BuiltInFormatters is a map of all formatters that we ship
-/*
-var BuiltInFormatters = map[string]formats.Formatter{
-	"json":       json.Formatter{},
-	"yaml":       yaml.Formatter{},
-	"plain":      plain.Formatter{},
-	"toml":       toml.Formatter{},
-	"csv":        csv.Formatter{},
-	"xml":        xml.Formatter{},
-	"gotemplate": gotemplate.Formatter{},
-}
-
-*/
diff --git a/formatters_test.go b/formatters_test.go
deleted file mode 100644
index 8dac72e..0000000
--- a/formatters_test.go
+++ /dev/null
@@ -1,8 +0,0 @@
-package gout
-
-/*
-func TestBuiltInFormatters(t *testing.T) {
-	require.Contains(t, BuiltInFormatters, "yaml")
-	require.NotContains(t, BuiltInFormatters, "never-exist")
-}
-*/
diff --git a/gout.go b/gout.go
index fbdba68..5c40a4a 100644
--- a/gout.go
+++ b/gout.go
@@ -1,3 +1,6 @@
+/*
+Package gout provides a custom G OUTput formatter
+*/
 package gout
 
 import (
@@ -7,8 +10,7 @@ import (
 	"os"
 
 	"github.com/drewstinnett/gout/v2/formats"
-	// Include all the builtin formats by default
-	_ "github.com/drewstinnett/gout/v2/formats/builtin"
+	_ "github.com/drewstinnett/gout/v2/formats/builtin" // Include all the builtin formats by default
 	"github.com/drewstinnett/gout/v2/formats/yaml"
 )
 
@@ -19,8 +21,15 @@ type Gout struct {
 	writer    io.Writer
 }
 
-// Use this for doing things without explicitely creating a new gout, similar to
+// Use this for doing things without explicitly creating a new gout, similar to
 // viper.Viper
+//
+// The pattern for usage is something like:
+// gout.Print("Hello")
+//
+// works similarly to:
+// custom := New()
+// custom.Print("Hello")
 var gi *Gout
 
 func init() {
@@ -36,24 +45,42 @@ func Get() *Gout {
 // will be os.Stdout
 func SetWriter(i io.Writer) { gi.SetWriter(i) }
 
+// SetWriter sets the writer on a custom Gout instance
 func (g *Gout) SetWriter(i io.Writer) {
 	g.writer = i
 }
 
-// SetFormatter sets the Formatter to use for the text.
+// SetFormatter sets the built in Gout instance
 func SetFormatter(f formats.Formatter) { gi.SetFormatter(f) }
 
+// SetFormatter sets the formatter on a custom Gout instance
 func (g *Gout) SetFormatter(f formats.Formatter) {
 	g.formatter = f
 }
 
+// SetFormatterString sets the formatter from the string that the plugin was registered with
+func SetFormatterString(s string) error {
+	return gi.SetFormatterString(s)
+}
+
+// SetFormatterString sets the formatter from the string that the plugin was registered with
+func (g *Gout) SetFormatterString(s string) error {
+	if f, ok := formats.Formats[s]; ok {
+		g.formatter = f()
+
+		return nil
+	}
+	return fmt.Errorf("unknown formatter name: %v", s)
+}
+
 // Print print an interface using the given Formatter and io.Writer
 func Print(v interface{}) (err error) { return gi.Print(v) }
 
+// Print prints the output on a custom Gout instance
 func (g *Gout) Print(v interface{}) (err error) {
 	defer func() {
 		if r := recover(); r != nil {
-			err = fmt.Errorf("Panic while attempting to format: %v", r)
+			err = fmt.Errorf("panic while attempting to format: %v", r)
 		}
 	}()
 	var b []byte
@@ -69,10 +96,11 @@ func (g *Gout) Print(v interface{}) (err error) {
 // serialized item
 func PrintMulti(v ...interface{}) (err error) { return gi.PrintMulti(v) }
 
+// PrintMulti prints multiple items on a custom gout instance
 func (g *Gout) PrintMulti(v ...interface{}) (err error) {
 	defer func() {
 		if r := recover(); r != nil {
-			err = fmt.Errorf("Panic while attempting to format: %v", r)
+			err = fmt.Errorf("panic while attempting to format: %v", r)
 		}
 	}()
 	var b []byte
@@ -88,6 +116,7 @@ func (g *Gout) PrintMulti(v ...interface{}) (err error) {
 // MustPrint print an interface and panic if there is any sort of error
 func MustPrint(v interface{}) { gi.MustPrint(v) }
 
+// MustPrint outputs data on a custom Gout instance
 func (g *Gout) MustPrint(v interface{}) {
 	err := g.Print(v)
 	if err != nil {
@@ -99,6 +128,7 @@ func (g *Gout) MustPrint(v interface{}) {
 // error
 func MustPrintMulti(v ...interface{}) { gi.MustPrintMulti(v) }
 
+// MustPrintMulti prints multiple items with a custom Gout instance
 func (g *Gout) MustPrintMulti(v ...interface{}) {
 	err := g.PrintMulti(v)
 	if err != nil {
diff --git a/gout_test.go b/gout_test.go
index fb096cd..efe2fd3 100644
--- a/gout_test.go
+++ b/gout_test.go
@@ -25,6 +25,11 @@ func TestSetGoutWriter(t *testing.T) {
 	// Make sure we can change the formatter
 	c.SetFormatter(plain.Formatter{})
 	require.IsType(t, plain.Formatter{}, c.formatter)
+
+	buf = bytes.Buffer{}
+	c.SetFormatterString("json")
+	c.Print(struct{ Foo string }{Foo: "bar"})
+	require.Equal(t, "{\"Foo\":\"bar\"}\n", buf.String())
 }
 
 func TestNewGoutWithWriter(t *testing.T) {
@@ -54,20 +59,16 @@ func TestPrintError(t *testing.T) {
 
 func TestBuiltinGout(t *testing.T) {
 	require.NotPanics(t, func() { MustPrint("foo") })
-
 	require.NotPanics(t, func() { SetWriter(os.Stderr) })
 	require.NotPanics(t, func() { SetFormatter(json.Formatter{}) })
-
-	err := Print("foo")
-	require.NoError(t, err)
-
-	err = PrintMulti("foo", "bar")
-	require.NoError(t, err)
-
+	require.NoError(t, Print("foo"))
+	require.NoError(t, PrintMulti("foo", "bar"))
 	require.NotPanics(t, func() { MustPrintMulti("foo", "bar") })
+	require.NotNil(t, Get())
 
-	got := Get()
-	require.NotNil(t, got)
+	require.NoError(t, SetFormatterString("plain"))
+	require.EqualError(t, SetFormatterString("never-exists"), "unknown formatter name: never-exists")
+	require.IsType(t, &plain.Formatter{}, Get().formatter)
 }
 
 func TestWriterPrinterMulti(t *testing.T) {
diff --git a/utils/util.go b/utils/util.go
deleted file mode 100644
index b8da3eb..0000000
--- a/utils/util.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package utils
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-)
-
-// GenericUnmarshal Given an arbitrary piece of data, return a slice of json data
-func GenericUnmarshal(data interface{}) ([]map[string]interface{}, error) {
-	j, _ := json.Marshal(data)
-	var jsonSlice []map[string]interface{}
-	baseObjType := reflect.ValueOf(data).Kind()
-	var objType string
-	if baseObjType == reflect.Struct {
-		objType = "struct"
-	} else if baseObjType == reflect.Slice {
-		objType = "slice"
-	} else if baseObjType == reflect.Ptr {
-		objType = reflect.ValueOf(data).Elem().Kind().String()
-	}
-	switch objType {
-	case "struct":
-		jsonMap := make(map[string]interface{})
-		err := json.Unmarshal(j, &jsonMap)
-		if err != nil {
-			return nil, err
-		}
-		jsonSlice = append(jsonSlice, jsonMap)
-	case "slice":
-		err := json.Unmarshal(j, &jsonSlice)
-		if err != nil {
-			return nil, err
-		}
-	default:
-		return nil, fmt.Errorf("Unknown type of data for gotemplate: %s", objType)
-	}
-	return jsonSlice, nil
-}
-
-// StringInSlice Check if a slice for a string
-func StringInSlice(a string, list []string) bool {
-	for _, b := range list {
-		if b == a {
-			return true
-		}
-	}
-	return false
-}
diff --git a/utils/utils_test.go b/utils/utils_test.go
deleted file mode 100644
index 02b1f4d..0000000
--- a/utils/utils_test.go
+++ /dev/null
@@ -1,117 +0,0 @@
-package utils
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestSliceContains(t *testing.T) {
-	t.Parallel()
-	s := []string{"foo", "bar", "baz"}
-
-	got := StringInSlice("bar", s)
-	require.True(t, got)
-}
-
-func TestSliceNotContains(t *testing.T) {
-	t.Parallel()
-	s := []string{"foo", "bar", "baz"}
-
-	got := StringInSlice("NeverExists", s)
-	require.False(t, got)
-}
-
-func TestGenericUnmarshalStruct(t *testing.T) {
-	type foo struct {
-		Name string `json:"name"`
-		Age  int    `json:"age"`
-	}
-	test := foo{
-		Name: "Drew",
-		Age:  25,
-	}
-	got, err := genericUnmarshal(test)
-	require.NoError(t, err)
-	require.Greater(t, len(got), 0)
-
-	f := fakeValue{
-		errors.New("fail"),
-	}
-	_, err = genericUnmarshal(f)
-	require.Error(t, err)
-}
-
-func TestGenericUnmarshalSlice(t *testing.T) {
-	test := []map[string]string{
-		{"foo": "bar"},
-		{"baz": "thing"},
-	}
-	got, err := genericUnmarshal(test)
-	require.NoError(t, err)
-	require.Greater(t, len(got), 0)
-}
-
-func TestGenericUnmarshalPtr(t *testing.T) {
-	test := []map[string]string{
-		{"foo": "bar"},
-		{"baz": "thing"},
-	}
-	got, err := genericUnmarshal(&test)
-	require.NoError(t, err)
-	require.Greater(t, len(got), 0)
-
-	f := fakeValue{
-		errors.New("fail"),
-	}
-	_, err = genericUnmarshal([]fakeValue{f})
-	require.Error(t, err)
-}
-
-type fakeValue struct {
-	err error
-}
-
-func (v fakeValue) MarshalJSON() ([]byte, error) {
-	if v.err != nil {
-		return nil, v.err
-	}
-
-	return []byte(`null`), v.err
-}
-
-// GenericUnmarshal Given an arbitrary piece of data, return a slice of json data
-func genericUnmarshal(data interface{}) ([]map[string]interface{}, error) {
-	j, _ := json.Marshal(data)
-	var jsonSlice []map[string]interface{}
-	baseObjType := reflect.ValueOf(data).Kind()
-	var objType string
-	if baseObjType == reflect.Struct {
-		objType = "struct"
-	} else if baseObjType == reflect.Slice {
-		objType = "slice"
-	} else if baseObjType == reflect.Ptr {
-		objType = reflect.ValueOf(data).Elem().Kind().String()
-	}
-	switch objType {
-	case "struct":
-		jsonMap := make(map[string]interface{})
-		err := json.Unmarshal(j, &jsonMap)
-		if err != nil {
-			return nil, err
-		}
-		jsonSlice = append(jsonSlice, jsonMap)
-	case "slice":
-		err := json.Unmarshal(j, &jsonSlice)
-		if err != nil {
-			return nil, err
-		}
-	default:
-		return nil, fmt.Errorf("Unknown type of data for gotemplate: %s", objType)
-	}
-	return jsonSlice, nil
-}