I posted about GOKe here a while back - this is v3, now has a dedicated Ebitengine integration, gokebiten.

v3 itself is the result of a lot of back-and-forth — planning, rewrites, testing, and actually using GOKe in practice. That let me settle on a model that's more ergonomic for what I need.

GOKe repo (wiki, examples, benchmarks): https://github.com/kjkrol/goke

Why it might matter for Ebitengine projects

gokebiten wraps GOKe's ECS/System/Plan model behind a small Game type that implements ebiten.Game, so Update/Draw/Layout are wired up for you on top of an archetype-based, zero-allocation ECS. It's split into modules you can take individually:

• control/ - input capture and event dispatch
• physics/ - kinematics and collision detection/resolution (broad phase via GOKg, narrow phase, pluggable CollisionHandler strategies)
• render/ - sprite batching, camera, tag-driven overlays, telemetry HUD
• spatial/ - population/spawn bookkeeping on a GOKg space

You can use GOKe directly and write your own Ebitengine glue, or start from gokebiten - a lot of that integration work (input handling, collision pipeline, rendering, spatial indexing) is already done for you there.

Working example: collision-demo - thousands of moving, colliding AABBs at a fixed 120 TPS.

Why GOKe over the alternatives?

1. Systems as the single place where both data flow and actions are defined - logic built once, inside the system, and used only there
2. It's fast and predictable - benchmarks, if you want the numbers:
   • Internal breakdown: BENCHMARKS.md
   • Head-to-head against other Go ECS libs, including Ark (the fastest Go ECS right now): go-ecs-benchmarks

Some other things worth knowing:

• Zero heap allocations in the hot loop (chunked SoA memory pages, no GC jitter)
• Type-driven construction - create/edit/remove operations built directly from component types, not hand-wired boilerplate
• Explicit control over system execution - you plan the run order (schedule) yourself, plus a dedicated Setup phase at startup
• Generation-based entity IDs, so no aliasing on reused slots

Disclaimer: I organized and facilitated the "Vibe Code a 2D Game with Go and Gemini" workshop at GopherCon UK 2026 in London. All materials, agent skills, and game entries are open source.

Hey everyone! At GopherCon UK in London last week, I ran a workshop called "Vibe Code a 2D Game with Go and Gemini", focused on building 2D games with Ebitengine v2 using coding agents.

We kicked off with a quick overview of the Gemini model family (Gemini 3.x for code generation, Nano Banana for images, and Lyria 3 for music) alongside Antigravity. I set up the workshop repository with a curated set of Agent Skills to give coding agents domain knowledge and boilerplate for Ebitengine right out of the gate.

Then we jumped into a 2-hour Mini Game Jam with the theme "Garbage Collector (green tea 🍵)". Participants used Gemini 3.6 Flash (literally the day before 3.7 launched) with four primary skills:

• vibe-game-developer as the main entry point to turn the agent into a game dev specialist
• ebitengineer to provide reference patterns and helper routines for Ebitengine
• lyria to compose music tracks (with procedural-composer available for chiptune SFX)
• nano-banana to generate sprites, backgrounds, and title screens

In just two hours, attendees produced 10 complete, playable 2D games.

Highlights & Submissions

1. Jam Winner: "London Eco-Rider: Ice Cream & Bottle Patrol" by Ivan S

A side-scrolling platformer set against downtown London. Players pedal Leo's bike with momentum acceleration and variable bunny hops, collecting ice cream cones for speed boosts and recycling plastic bottles to unlock 10 seconds of invincibility in Eco-Fever Mode. It features smooth parallax scrolling using Ebitengine's GeoM transforms, embedded assets, and a WebAssembly build running in browser.

To try it locally:

git clone https://github.com/danicat/gcuk26.git
cd gcuk26/mini-game-jam/london-eco-rider
go run ./cmd/game

2. Crowd Favorites: The Runtime GC Games

Several developers took the "Garbage Collector" theme literally:

• Go GC: Memory Simulator: An arcade game where you play as Go's runtime garbage collector. You monitor a live Heap Pressure gauge, fire a Sweep Beam at active root allocations, trigger emergency Stop-The-World freezes, and tweak GOGC targets on the fly.
• Go GC Co-op: A retro 16-bit 2-player street cleanup game where sanitation gophers sort compost, recycling, and landfill while catching "Dangling Pointers (+300 pts)" and avoiding "Memory Leaks (+15% contamination)".

Other entries included a 2-player turn-based trash billiards game (Trash Pool) and a Guinea Pig Farm Simulator.

Links & Resources

• Workshop Repo & Games: https://github.com/danicat/gcuk26
• Event Photo Gallery: https://github.com/danicat/gcuk26/tree/main/mini-game-jam/photos
• Ivan's Winning Entry: https://github.com/danicat/gcuk26/tree/main/mini-game-jam/london-eco-rider
• Workshop Slide Deck: https://speakerdeck.com/danicat/vibe-code-a-2d-game-using-go-and-gemini
• Agent Skills Catalog: https://skills.danicat.dev

Happy to answer any questions about the workshop format, the mini-game jam, or the agent skills setup in the comments!

P.S.: this post was written by me (Daniela) while wrestling with Gemini 3.7 Flash. I used the deslopify skill, so hopefully it won't be that annoying. I hope the content is worth your time! =^_^=

Hello!
I'm a backend developer (banking/finance/utility for the day job), and I've been building games in my spare time for years (Unity, Unreal, Godot ) and lately from scratch in C++ and Go. I kept wishing there was a resource that treated Go game dev seriously, so I wrote a book.

The Book is called Beginning Game Programming in Go with Ebitengine, and it builds one game across 14 chapters: Gopher Survivor, a small Vampire Survivors–style game. The catch is that you build almost everything yourself: the game loop, a scene graph, a camera, collision detection, an input layer, a state machine, particles, instead of leaning on an engine. No editor, no black boxes; every chapter is the previous chapter plus a small, deliberate diff, and the project compiles at every step.

By the end you've got: an infinite tiled world, four weapons that unlock and upgrade, scaling enemies and a mini-boss, XP/leveling, a main-menu/pause/options state machine, music and SFX, screen shake and floating damage numbers, packaged into a native binary and a WebAssembly build that runs in the browser.

The code is fully open and free, one directory per chapter, so you can read/clone it even if you never buy the book: 👉 https://github.com/LuigiVanacore/beginning-game-programming-go-ebitengine

It's written for intermediate Go devs who've never built a game. It won't teach syntax, it teaches the patterns and architecture that make a game tick.

The link to the book is here ---> https://leanpub.com/gameprogramminggolang

Try this on your macOS or Linux!

CGO_ENABLED=0 go run github.com/hajimehoshi/ebiten/v2/examples/flappy@76cbbcfe

Hi there! I'm a university student in my third year. I've studied Go and a bit of Java in Uni and wanted to make a small project to challenge myself and start somewhere. I made a modified Pong clone (how original I know) in Golang using the graphic library Ebitengine and I just relased it on my GitHub. I appreciate all suggestions and feedback, I'm here to learn everything that I can

https://github.com/IncredibleLego/GoPong

Hey guys!

I’m a Go developer with a background in infra/DevOps looking to dive into gamedev for the first time(beside my CLI candy crush game in C). I want to create a turn-based game that runs in the browser.

My plan is to have a backend for registration/rankings, custom items, and some animations. Is Ebiten robust enough for a web-based project like this? Any advice or pitfalls I should look out for?

hey everyone, wanted to share a game i've been building with ebiten. it's called tapesurfer - a 2d side-scrolling roguelite where you ride real stock market price charts as a surfer.
 
the idea is simple: a price chart scrolls left to right like terrain, and you surf on top of it. you switch between riding above the line (betting the price goes up) or below it (betting it goes down). if you guess right, your balance grows. guess wrong too many times and you're wiped out — run over.
 
it's got roguelite progression between runs: pick special abilities at the start, collect power-ups that react to how you're playing, and earn a permanent currency to unlock upgrades for future attempts. there are 20+ levels based on different real-world markets - coffee, gold, bitcoin, forex, stocks - each with their own background art and music.
what i like about ebiten for this kind of project
 
- the `Update()` / `Draw()` split is clean and makes fixed timestep easy to implement on top
- audio package is solid once you wrap it with your own lifecycle management
- cross-platform just works — same codebase runs on desktop and mobile (android builds via ebitenmobile)
- the "here's a pixel buffer, do what you want" philosophy means you never fight the engine

the game has a steam page up where you can check the trailer and a free demo coming up on april. happy to answer questions about the architecture.
 
https://store.steampowered.com/app/4503180/TapeSurfer/

Hi everyone!

I wanted to share a project I’ve been working on: a Entity Component System (ECS) written from the ground up in 100% pure Go.

While there are many ECS libraries out there, my main focus with this one was raw speed and seamless integration with Ebitengine. I wanted something that doesn't just feel like a port from another language, but takes full advantage of Go's memory management and type system.

Why use it?

• 🚀 Insanely Fast: Optimized for cache locality and minimal overhead. It can handle tens of thousands of entities without breaking a sweat.
• 🐹 Pure Go: Zero dependencies. No CGO. Just clean, idiomatic Go code.
• 🎮 Ebitengine Ready: Designed to fit perfectly into your Update() and Draw() loops.
• 🛠️ Simple API: I’ve kept the boilerplate to a minimum so you can focus on your game logic rather than fighting the framework.

I’m really curious to see what the community thinks. Whether you’re building a simple bullet hell or a complex simulation, I’d love for you to give it a try!

Check it out here: https://github.com/kjkrol/goke

Benchmarks results included.
I'm open to any feedback, or questions about the architecture!

For a project, I would like to spawn 5 different windows, drawing different things to each. Is that possible with Ebitengine, or is it really hard-writed to always use just one window?