Go Formatter (gofmt)

One canonical layout, no settings

Go is unusual in that the language ships its own formatter and almost every Go project uses it unchanged. There is no style guide to argue about: gofmt decides, and code review tools, editors and CI all expect its output. That is why this page has no format-specific options. What you get here is byte-for-byte what gofmt writes, because the formatter is the Go standard library’s printer compiled to WebAssembly rather than a reimplementation.

The toolbar’s Indent choice is ignored on purpose. gofmt always indents with tabs and uses spaces only for alignment, so switching to 2 or 4 spaces would produce code that a gofmt -l check in CI would flag as unformatted.

What gofmt changes

• Spacing by precedence. Operators get spaces according to how tightly they bind, so i*2+1 becomes i*2 + 1. That is intentional, not a bug.
• Alignment. Consecutive struct fields, their tags, const and var blocks and trailing comments are lined up in columns.
• Imports. Inside a parenthesised import (...) block, each run of lines is sorted alphabetically. Blank lines separate runs, so the common split between standard library and third-party packages survives.
• Semicolons and commas. Statements separated by semicolons are put on their own lines, and a trailing comma before a closing brace on the same line is dropped. A brace on its own line is not something gofmt can fix: Go’s automatic semicolon insertion makes that a syntax error.

What it does not do matters just as much. There is no line length limit, so a long call stays long. A function body you wrote on one line, like func main() { run() }, may stay on one line. Unused imports are not removed and missing ones are not added; that is goimports, a separate tool.

Snippets without a package clause

You do not need a complete file. gofmt accepts a list of declarations, or even a few statements such as the body of a function, and formats them in place. That makes it practical for tidying code copied from a Slack thread, a GitHub comment or an answer on a forum before you drop it into an editor. Only the syntax is checked: undefined names, type mismatches and unused variables are compile errors, which gofmt never sees.

Using the page

Paste a file, or open one with the file button. A package line followed by a func, or a function using :=, is enough for automatic detection. Press Ctrl/Cmd+Enter to run gofmt, then Ctrl/Cmd+Shift+C to copy the output. If the input does not parse, the message starts with line:column, and the error is highlighted at that spot in the editor. Formatting happens on your own machine, so internal service names and credentials in the code stay private.

The output contains real tab characters. Editors display them at your configured width, but some web forms, chat tools and Markdown renderers show a tab as 8 columns, so deeply nested code can look wider after pasting than it does in your editor. The code itself is unchanged.

Examples

package main
import ("net/http";"fmt";"encoding/json")
type Order struct{ID string `json:"id"`;Status string `json:"status"`;Total float64 `json:"total"`}
func getOrder(w http.ResponseWriter,r *http.Request){
o:=Order{ID:r.URL.Query().Get("id"),Status:"paid",Total:208.9}
w.Header().Set("Content-Type","application/json")
if err:=json.NewEncoder(w).Encode(o);err!=nil{http.Error(w,err.Error(),http.StatusInternalServerError)}}
func main(){http.HandleFunc("/order",getOrder);fmt.Println("listening on :8080");http.ListenAndServe(":8080",nil)}

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

type Order struct {
	ID     string  `json:"id"`
	Status string  `json:"status"`
	Total  float64 `json:"total"`
}

func getOrder(w http.ResponseWriter, r *http.Request) {
	o := Order{ID: r.URL.Query().Get("id"), Status: "paid", Total: 208.9}
	w.Header().Set("Content-Type", "application/json")
	if err := json.NewEncoder(w).Encode(o); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}
func main() {
	http.HandleFunc("/order", getOrder)
	fmt.Println("listening on :8080")
	http.ListenAndServe(":8080", nil)
}

package collections
import (
"strings"
"fmt"

"github.com/acme/billing/zeta"
"github.com/acme/billing/alpha"
)
func Map[T,U any](xs []T,f func(T)U)[]U{out:=make([]U,0,len(xs));for _,x:=range xs{out=append(out,f(x))};return out}

package collections

import (
	"fmt"
	"strings"

	"github.com/acme/billing/alpha"
	"github.com/acme/billing/zeta"
)

func Map[T, U any](xs []T, f func(T) U) []U {
	out := make([]U, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}

for i:=0;i<len(orders);i++ {
if orders[i].Total==0 {continue}
total+=orders[i].Qty*orders[i].Price+shipping
}

for i := 0; i < len(orders); i++ {
	if orders[i].Total == 0 {
		continue
	}
	total += orders[i].Qty*orders[i].Price + shipping
}

Common errors and how to fix them

Related tools

• JSON to Go
• cURL to Go net/http
• Rust formatter
• Zig formatter
• Python formatter
• Dockerfile formatter
• YAML formatter