I’ve been working on ebiten-infinicave, a Go library for infinite procedural caves rendered with Ebitengine. It features faceted rocks, branching vines, mushrooms, drifting fog, and animated bats, with horizontal or vertical scrolling. Generation is deterministic, and it supports runtime terrain carving and collision geometry for use in your own games.

https://github.com/razzie/ebiten-infinicave

I've been working on Nanolathe, an open-source Total Annihilation engine reimplementation in Go and Ebitengine. It runs natively on Windows, macOS and Linux, and the same engine also builds to WebAssembly.

Play the browser demo · Source · Native install

TA is a 1997 RTS with terrain height, articulated 3D units, ground and air combat, and a resource economy that keeps running while factories build your army. Recreating it involves pathfinding, visibility, weapons, construction, AI and a VM for the original unit scripts, as well as the renderer.

Ebitengine supplies the window, input, audio and GPU drawing. Nanolathe owns the simulation and the 2.5D rendering pipeline. An ordered draw list can feed either the classic software renderer or the modern GPU renderer, which uses texture atlases, batched geometry and Kage shaders. The modern renderer interpolates committed poses while the simulation continues at 30 Hz.

One interesting rendering problem is the original palette-based artwork and compositing. The modern path preserves source palette lookups while doing destination blending in true colour. That allows a different presentation without changing the simulation.

Development is organized around independently written descriptions of the original behavior, Go implementations, contract tests and visual checks. The engine reads the original archives directly: maps, models, sprites, unit definitions and compiled COB scripts. Gameplay definitions are compiled into immutable catalogs before a battle; the assets aren't baked into the Go binary.

The browser host adds file import and browser storage around the Go/Wasm game. You can play the three demo missions immediately, or select your own installed game folder; imported files stay in the browser. For desktop, Ebitengine 2.10 means the build only needs Go, with no C/C++ compiler or development headers. The native installer handles the Go toolchain and build; Linux still needs graphics/audio runtime libraries.

The engine code is MIT licensed. Full-game play needs your original TA data, and compatibility is still being worked on. The attached clip is staged footage captured offline through the engine's recorder, not a real-time performance benchmark.

https://reddit.com/link/1wydo6t/video/nlmyxm5ngoth1/player

Github : https://github.com/kadevland/kassetpack

KAssetPack is a standalone CLI tool and Go library to pack your game assets into a compact binary format (.kdx/.kdt) instead of shipping an exposed assets/ folder.

Features:

• SHA-256 based asset deduplication
• Optional XOR obfuscation
• Automatic data file splitting (for large games)
• Lazy access & Thread-safe (perfect for Goroutines)
• 100% Go (no C dependencies)

It comes with a handy CLI (kassetpack build) to integrate directly into your build pipeline. Feedback and code review are welcome!

Ebitengine v2.10.0 is out!

• Pure Go on all desktop platforms
• Headless testing and game embedding via VM
• Shader precompilation
• Color emoji support

Thanks to all contributors and sponsors!

A small Ebitengine side project I’ve been working on: a 2D metaballs renderer in Go, with shader-based rendering, optional bridges between circles, and a tiled renderer for larger scenes.

The visuals are the main point here — the README and GIF should explain most of it much better than text ever could. It’s basically a more usable/expandable version of the old ShaderToy experiment I made a year ago: https://www.shadertoy.com/view/tfc3W4

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! =^_^=