Raylib-Go on Game Experiments

Tetris

Wed, 22 Apr 2026 16:14:05 -0600

Build a Tetris game using Go and Raylib

Earlier we saw how to create a Raylib Go project.

This series assumes you understand the basics of Go. If not Take a look at my Go for Beginners Section. We will end up with a full Tetris Game and I will keep it simple enough if you know about variables and functions.

We are loosely basing this on a C++ YouTube tutorial found here

Make the project folder

Using a terminal copy this code. Open up your terminal app from your dev folder and type the following

mkdir tetris
cd tetris
go mod init example.com/tetris
echo "" > main.go

then copy this into the main.go file we just created (like we did in hello.go)

package main

import rl "github.com/gen2brain/raylib-go/raylib"

func main() {
  rl.InitWindow(800, 450, "Tetris")
  defer rl.CloseWindow()

  rl.SetTargetFPS(60)

  for !rl.WindowShouldClose() {
    rl.BeginDrawing()

    rl.ClearBackground(rl.RayWhite)
    rl.DrawText("Congrats! You created your first window!", 190, 200, 20, rl.LightGray)

    rl.EndDrawing()
  }
}

Now from the terminal run

1
2

go mod tidy
go run .

We should have a window like we did before. If not refer to the first project mentioned above.

Grid

What we want is something like this

First we need to:

make a grid 10x20
set and clear grid positions
visual test our grid works as expected

We could create an array of 120 length and set NumCols to 10, and NumRows to 20.

var Grid [120]int
NumRows = 20
NumCols = 10

Why don’t we make it more flexible by using a Slice aka Dynamic Array? We can make it any size based on rows and columns. We can also clear and recreate between levels.

Above the main function add this

var NumRows int
var NumCols int

var Grid []int

and in main we can add (after the defer window close)

NumRows = 20
NumCols = 10

Grid = make([]int, NumCols*NumRows)

This creates an array with the size of 200.

Go has a memory manager which makes it a high level language. However, it can’t manage memory allocated in C code which is why we use defer the Raylib close window function.

Ok so at some point we want to set values in the grid. We also want to do it multiple times throughout the game.

Let’s create a function that sets a value on the grid at a given row and col. We add this after the closing brace of the main function

1
2
3

func setValAt(x, y, value int) {
	Grid[y*NumCols+x] = value
}

Notice the Y is multiplied by the number of columns. This is because the array is 1 dimensional. i.e.

012345678901234567890123456789...

So each row is 10 columns 0->9 and the next one follows right behind. The second starting at position 10 (11th cell where 0 is the first)

To get the 4th row we multiply by (4-1)*number_of_cells_in_a_column i.e. position 30 or 31st cell.

Ok enough of the beginner stuff

We are not done with the function yet

What happens if we pass an invalid number into our function. It would be an error at runtime and that is something we want to avoid. Let us add out of range errors.

func setValAt(x, y, value int) error {
	if x >= NumCols || x < 0 {
		return errors.New("x position out of range")
	}
	if y >= NumRows || y < 0 {
		return errors.New("y position out of range")
	}
	Grid[y*NumCols+x] = value
	return nil
}

We won’t use the returned errors. Not yet! n.b. you should always, but we have no supporting code yet.

1
2
3

	setValAt(0, 0, 1)
	setValAt(3, 5, 4)
	setValAt(17, 8, 7)

Here we set the values of two cells and the third should give an error. The column number is greater than the number of columns.

Now we want to test this (without writing tests) by using a function that prints all 20 rows to the terminal output.

func Print() {
	for r := 0; r < NumRows; r++ {
		s, _ := getRowAt(r)
		fmt.Println(s)
	}
}

We added “error” and “fmt” which is in the Core library but still needs to be imported into our code.

import (
    "errors"
    "fmt"

    rl "github.com/gen2brain/raylib-go/raylib"
)

lastly we need to call the print function - add that below the setValAt function calls i.e

	NumRows = 20
	NumCols = 10
	CellSize = 30
	Grid = make([]int, NumCols*NumRows)

	setValAt(0, 0, 1)
	setValAt(3, 5, 4)
	setValAt(17, 8, 7)
	Print()

If we run this now, we should get the following being displayed in the terminal (unless you are hiding the terminal with a compile time flag)

Our final code in main looks like

package main

import (
	"errors"
	"fmt"

	rl "github.com/gen2brain/raylib-go/raylib"
)

var NumRows int
var NumCols int
var CellSize int
var Grid []int

func main() {
	rl.InitWindow(800, 450, "raylib [core] example - basic window")
	defer rl.CloseWindow()

	NumRows = 20
	NumCols = 10
	CellSize = 30
	Grid = make([]int, NumCols*NumRows)

	setValAt(0, 0, 1)
	setValAt(3, 5, 4)
	setValAt(17, 8, 7)
	Print()

	rl.SetTargetFPS(60)

	for !rl.WindowShouldClose() {
		rl.BeginDrawing()

		rl.ClearBackground(rl.RayWhite)
		rl.DrawText("Congrats! You created your first window!", 190, 200, 20, rl.LightGray)

		rl.EndDrawing()
	}
}

func setValAt(x, y, value int) error {
	if x >= NumCols || x < 0 {
		return errors.New("x position out of range")
	}
	if y >= NumRows || y < 0 {
		return errors.New("y position out of range")
	}
	Grid[y*NumCols+x] = value
	return nil
}

func getRowAt(y int) ([]int, error) {

	if y >= NumRows || y < 0 {
		return nil, errors.New("y position out of range")
	}
	start := y * NumCols
	end := start + NumCols
	s := Grid[start:end]

	return s, nil
}

func Print() {

	for r := 0; r < NumRows; r++ {
		s, _ := getRowAt(r)
		fmt.Println(s)
	}

}

NOTE:

Computer programming is a strange beast mostly because of people and the different standards they have.

I expect 3 things from you.

Runs well
Is easy to read
All known bugs fixed

Is easy to read means ‘You can understand the code by looking at it’, even if it is a year later.

REFERENCE: Programming With Nick. Creating Tetris in C++ with raylib - Beginner Tutorial (OOP) url: https://www.youtube.com/watch?v=wVYKG_ch4yM

Go & Raylib Setup. To CGO or not to CGO

Tue, 21 Apr 2026 14:37:00 -0700

What

This post explains how to use Go and Raylib with CGO or without CGO.

WHY (AI Overview)

Using raylib-go via the CGO method is often preferred for its deep integration with the original C library and its expansive platform support. The primary reasons for choosing this method include:

Access to the Full raylib API: Using CGO allows the raylib-go bindings to directly call the native raylib C functions, ensuring that nearly all original features—including complex 3D rendering, shaders, and advanced audio—are available in Go.
Direct Library Integration: The raylib C source code is often included and compiled alongside the Go bindings when using CGO, providing a self-contained environment that doesn’t require separate pre-compiled binary management.
Broad Platform Compatibility: While Windows offers a CGO-less alternative, CGO remains the standard path for supporting many platforms like Linux (including native DRM/evdev for Raspberry Pi) and macOS.
Knowledge Portability: Because the bindings closely mirror the raylib C API, developers can easily adapt tutorials, examples, and community solutions written for C or C++ directly into their Go projects.
Performance for Intensive Logic: Using Go for the “business logic” while leveraging the high-performance C backend of raylib for rendering provides a balance between rapid development and runtime efficiency.
System-Level Control: CGO provides the low-level system interaction necessary for a game engine that Go’s standard library does not expose by itself, such as direct windowing and GPU context management.

While CGO is the standard, developers should be aware of trade-offs such as slower build times and the requirement of a C toolchain (like GCC or Clang) on the development machine.

Intro

GO is high-level and has low-level performance. You should have a firm understanding of the basics within a few hours to a week.

You heard it was for server backends for websites? Its a general purpose language meaning it was designed for almost all scenerios.

I will use Raylib for games and likely Gio for apps. other options Awesome-GO.

Windows users:
Terminal is a windows app that allows you to run powershell or cmd or other shells. If you using windows 10 or newer and it doesn't have terminal you can install via the store.

What we will need

and either (for raylib)

C compiler
.dll

You can use a common text editor and the terminal for the rest of the instructions

Get Go

Go to GO.DEV downloads follow the instructions for your system.

There are many ways to install the software. If you are unfamiliar and on windows then use the MSI.

Mine is a 64 bit computer, so I use go1.26.2.windows-amd64.msi.

I downloaded the MSI and ran it. You are asked to accept the terms and shown where the go files are installed.

Once done open a new terminal and type in

`1`	`go version`

Now what?

Go installs itself in a few places. It will install a go folder under your home folder. This is for dependancies like raylib-go.

You can do your development anywhere. I usually have a dev folder in my HOME folder.

Old tutorials refer to a GOPATH -> you can ignore that now.

Go modules

This is used for a collection of go packages. Don’t worry about this now, but if you want to know take a look at https://go.dev/blog/using-go-modules

Create Your first Module

Make a folder for your projects

here are command line instructions

cd ~
mkdir dev
cd dev
mkdir hello
cd hello

Above commands:

puts you in your home folder
makes a development folder for all future projects
moves us into the development folder
create a project folder called hello
move into the project folder

Then do the following from the terminal

`1`	`go mod init example.com/hello`

We create a file called hello.go and place the following code in it.

package main

import "fmt"

func main() {
	fmt.Println("Hello, world")
}

We can run this short app using this terminal command

`1`	`go run .`

The dot means ’this folder’. You can replace dot with hello.go

Great it should display “Hello, world” below our command if all is well

You can now run the following to make a module and Build our code

Check for package changes and dependancies.

`1`	`go mod tidy`

Create an executable

`1`	`go build .`

Ok Go works!

Now Raylib-go

You can refer to the raylib-go instructions

Windows Users

NO CGO

Get the Raylib dll from the Raylib Releases Page. Get one of the Win64 zip files from the 5.5 or higher release and extract. the dll will be in one of the folders.

Scroll down to find:

the win32 ones are for 32bit systems and the win64 for 64bit systems. If you dont know and your are using a laptop or desktop you likely will be satisfied with raylib-5.5_win64_msvc16.zip

Click on that file and it should download

open up the downloaded ZIP file by clicking on it using windows explorer. and click on the folder inside and then on the libs folder

right click and copy-paste that into your project folder called “hello”

Skip to Add Code

CGO

We need a c compiler which is not commonly on Windows.

We could use the windows build tools though I prefer the open source compiler mingw64 to make my project.

The easiest way is to get Winlibs

download and extract to a place where you’ll find it. I create a folder called portable in the C root folder or my home folder and add extract apps that “don’t install” there.

I extracted mine too C:\Portable\mingw64 and add C:\Portable\mingw64\bin to the PATH in my environment variables.

Close the Terminal and re-open. This now includes the new PATH variable.

Add Code

Reopen the hello.go file and replace the code with the following code and save.

package main

import rl "github.com/gen2brain/raylib-go/raylib"

func main() {
  rl.InitWindow(800, 450, "raylib [core] example - basic window")
  defer rl.CloseWindow()

  rl.SetTargetFPS(60)

  for !rl.WindowShouldClose() {
    rl.BeginDrawing()

    rl.ClearBackground(rl.RayWhite)
    rl.DrawText("Congrats! You created your first window!", 190, 200, 20, rl.LightGray)

    rl.EndDrawing()
  }
}

Run the following command again

`1`	`go mod tidy`

and then run the app

`1`	`go run .`

Yahoo!

Where to learn more

The Go web site has some Go tutorials and a list of places to learn so does Awesome Go and many others.

Books and Tutorials

A list of GO e-books
A list of GO tutorials
The Go Language Website - Learn
Exercism.org - recommended teaches a few basics and then challenges you with interactive tests on the site so that you can practice what you learn.
Avery makes games this is one short series

I suggest reading learn go with tests. I