How to reverse a string in Go

1[]rune and a two-pointer swapRecommended

[]rune(s) decodes the UTF-8 bytes into one int32 per character, and a rune slice is mutable — so you can swap the ends inward and convert back. This is the canonical answer: no imports, no dependencies, and it works on every Go version.

package main

import "fmt"

// Reverse returns s with its characters in reverse order.
func Reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func main() {
	fmt.Println(Reverse("Compile"))
	fmt.Println(Reverse("Go 言語"))
}

Prints elipmoC and 語言 oG — the Japanese survives intact because the swap moves whole runes, never half a character. The loop stops at i < j, so an odd-length string simply leaves its middle rune where it is.

2slices.Reverse (Go 1.21+)

Since Go 1.21 the standard library ships slices.Reverse, which reverses any slice in place. Hand it a []rune and the whole function collapses to three lines. It is still runes doing the work — slices.Reverse on a []byte would break UTF-8 exactly like a hand-rolled byte swap.

package main

import (
	"fmt"
	"slices"
)

func Reverse(s string) string {
	runes := []rune(s)
	slices.Reverse(runes)
	return string(runes)
}

func main() {
	fmt.Println(Reverse("Compile"))
	fmt.Println(Reverse("Go 言語"))
}

Same output as the manual swap: elipmoC and 語言 oG. Reach for this on modern Go; keep the explicit loop if you must build against 1.20 or earlier, where the slices package doesn't exist.

3Building the result in a loop

You can also build a new string as you walk the old one. Ranging over a string yields runes (not bytes), so prepending each one reverses the text — but out = string(r) + out allocates a fresh string every iteration, which is O(n²) work. strings.Builder fixes that: one buffer, sized up front with Grow, written back to front.

package main

import (
	"fmt"
	"strings"
)

// Naive: every assignment allocates a whole new string.
func reverseConcat(s string) string {
	out := ""
	for _, r := range s { // range yields runes, not bytes
		out = string(r) + out
	}
	return out
}

// Same idea, one buffer: write the runes back to front.
func reverseBuilder(s string) string {
	runes := []rune(s)

	var b strings.Builder
	b.Grow(len(s))
	for i := len(runes) - 1; i >= 0; i-- {
		b.WriteRune(runes[i])
	}
	return b.String()
}

func main() {
	fmt.Println(reverseConcat("Compile"))
	fmt.Println(reverseBuilder("Go 言語"))
}

Both print the same answers as section 1 — elipmoC and 語言 oG. b.Grow(len(s)) takes the byte length, which is exactly what the builder needs: the reversed string has the same bytes, just reordered.

4Why reversing []byte breaks

This is the version people write first, and it is fine only if you can guarantee pure ASCII. len(s) counts bytes, indexing s[i] gives a byte, and a multi-byte character reversed byte-by-byte becomes an invalid sequence — which Go renders as �, the replacement character.

package main

import "fmt"

// Reverses BYTES, not characters -- correct for ASCII only.
func reverseBytes(s string) string {
	b := []byte(s)
	for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
		b[i], b[j] = b[j], b[i]
	}
	return string(b)
}

func main() {
	s := "caf\u00e9" // "caf" + U+00E9, the letter e-acute

	fmt.Println(len(s), "bytes,", len([]rune(s)), "runes")

	// range decodes UTF-8: i is a byte offset, r is a rune
	for i, r := range s {
		fmt.Printf("%d\t%c\n", i, r)
	}

	fmt.Println(reverseBytes("Compile")) // ASCII: fine
	broken := reverseBytes(s)            // not ASCII: mojibake
	fmt.Println(broken)
	fmt.Printf("%q\n", broken)
}

The first line prints 5 bytes, 4 runes, and the range loop's indexes go 0 c, 1 a, 2 f, 3 é — note there is no index 4, because é occupies bytes 3 and 4. Compile reverses cleanly to elipmoC, but café comes back as two replacement characters followed by fac; %q shows the truth — "\xa9\xc3fac", the two bytes of é swapped into nonsense.

5Which should you use?

6Reverse the words in a sentence

Different task, same shape. strings.Fields splits on any run of whitespace and drops the empties, so you get a clean []string; swap it end-to-end and strings.Join it back. Use strings.Split(s, " ") instead only when you need to preserve empty fields.

package main

import (
	"fmt"
	"strings"
)

func reverseWords(s string) string {
	words := strings.Fields(s)
	for i, j := 0, len(words)-1; i < j; i, j = i+1, j-1 {
		words[i], words[j] = words[j], words[i]
	}
	return strings.Join(words, " ")
}

func main() {
	fmt.Println(reverseWords("code every day"))
	fmt.Println(reverseWords("  ship   it   fast  "))
}

Prints day every code and fast it ship — the second line shows Fields normalising the runs of spaces and the leading/trailing padding away for free. The characters inside each word are untouched; only the word order flips.

7Where runes still aren't enough

Runes are code points, and a user-perceived character can be several of them. An accent written as a combining mark is two runes (e + U+0301), so reversing floats the accent onto the wrong letter. Flags are worse: 🇬🇧 is two regional-indicator runes, and reversing them turns the UK into Bulgaria.

package main

import "fmt"

func Reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func main() {
	// One rune: U+00E9, the single letter e-acute
	fmt.Println(Reverse("caf\u00e9"))

	// Two runes: 'e' + U+0301 COMBINING ACUTE ACCENT -- the accent moves
	fmt.Printf("%q\n", Reverse("cafe\u0301"))

	// A flag is two regional indicators, so GB reverses into BG
	fmt.Println(Reverse("\U0001F1EC\U0001F1E7"))
}

The pre-composed café reverses cleanly to éfac. The decomposed spelling prints "́efac" — the combining accent is now the first rune, attached to nothing. And the flag comes back as 🇧🇬. Rune reversal is the right answer for ordinary text; if you must reverse arbitrary user input exactly, segment it into grapheme clusters first with a package like github.com/rivo/uniseg, then reverse the clusters.