The Sierpinski Triangle is a wellknown fractal that exhibits selfsimilarity, meaning it looks the same at different scales. This pattern is formed by recursively subdividing an equilateral triangle into smaller triangles. In this blog post, we'll explore how to generate a Sierpinski Triangle using the Go programming language.
Understanding the Sierpinski Triangle
The Sierpinski Triangle starts with a single equilateral triangle. This triangle is subdivided into four smaller equilateral triangles, and the central triangle is removed. This process is repeated recursively for the remaining triangles. The result is a fractal pattern that is infinitely complex, yet can be described with a simple recursive algorithm.
Why Use Go?
Go, also known as Golang, is a modern programming language designed for simplicity and efficiency. It is particularly wellsuited for concurrent programming and has a rich standard library. Using Go to generate the Sierpinski Triangle allows us to leverage its straightforward syntax and powerful features.
Generating the Sierpinski Triangle in Go
We will use a simple consolebased approach to generate and display the Sierpinski Triangle. Below is the Go code to create this fractal pattern:
package main
import (
"fmt"
"strings"
"unicode/utf8"
)
func main() {
var order = 4
var star = "*"
t := []string{star + strings.Repeat(" ", utf8.RuneCountInString(star))}
for ; order > 0; order {
sp := strings.Repeat(" ", utf8.RuneCountInString(t[0])/2)
top := make([]string, len(t))
for i, s := range t {
top[i] = sp + s + sp
t[i] += s
}
t = append(top, t...)
}
for _, r := range t {
fmt.Println(r)
}
}
output
*
* *
* *
* * * *
* *
* * * *
* * * *
* * * * * * * *
* *
* * * *
* * * *
* * * * * * * *
* * * *
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * *
Run code on Go PlayGround
Code Explanation
Let's break down the code to understand how it generates the Sierpinski Triangle.

Imports and Initialization:
import ( "fmt" "strings" "unicode/utf8" )
We import the necessary packages. The
fmt
package is used for printing,strings
for string manipulation, andunicode/utf8
for counting runes in a string. 
Main Function:
func main() { var order = 4 var star = "*"
We define the order of the triangle, which determines the depth of recursion, and the character used to draw the triangle (
star
). 
Initial Triangle Setup:
t := []string{star + strings.Repeat(" ", utf8.RuneCountInString(star))}
We initialize the first row of the triangle with a single star followed by spaces.

Generating the Triangle:
for ; order > 0; order { sp := strings.Repeat(" ", utf8.RuneCountInString(t[0])/2) top := make([]string, len(t)) for i, s := range t { top[i] = sp + s + sp t[i] += s } t = append(top, t...) }
The loop runs for the specified order, generating the triangle. For each iteration:
 We calculate the spaces needed to centeralign the current rows (
sp
).  Create a copy of the current rows (
top
) and update them to include spaces on both sides.  Update the original rows (
t
) by duplicating the pattern.  Append the modified rows (
top
) tot
to create the next level of the triangle.
 We calculate the spaces needed to centeralign the current rows (

Printing the Triangle:
for _, r := range t { fmt.Println(r) }
Finally, we print each row of the triangle.
Running the Code
To run the code, save it to a file named main.go
and execute the following commands in your terminal:
go run main.go
You should see an output resembling a Sierpinski Triangle, depending on the specified order.
Conclusion
Creating a Sierpinski Triangle in Go is a great way to explore recursive algorithms and understand how fractals work. Go's simplicity and performance make it an excellent choice for such tasks. This code provides a basic but powerful demonstration of generating fractal patterns using recursion. Feel free to experiment with different orders and characters to create your unique fractal art. Happy coding!