Ebiten VS go

Reading ebiten docs and source code they very clearly state that writing RGBA bytes to an image is slow, and shouldn't really be done every frame, at least many times per frame. This is where I thought my performance was being lost, and it sent me looking for answers for ages. Turns out, I was wrong and right.

I love Go, yet I've never thought of it as a language with usable game engines. I'm extremely happy to find I was very wrong about that!

I'm woefully behind the curve on compiling to WASM, though, and I've yet to experiment much with tinygo so I have no idea how far I would get in creating a game people could enjoy in a browser without having to download a big bundle of assets. It's reassuring to see WASM mentioned explicitly as a compilation target [1] by Ebitengine though.

[1] https://github.com/hajimehoshi/ebiten

For other OSes, see https://github.com/hajimehoshi/ebiten/issues/1162

What about learning Go with Ebiten? Or Rust with Bevy?

Actually, there is a game engine in Go. Ebiten(gine) is actually really popular and has already been used for a few games in production

Check out this thread, some of the linked repositories might be of help. https://github.com/hajimehoshi/ebiten/discussions/1527

// consider having a laser type to deal with orientation, etc // basic information to draw sprites, track position and update position type Body struct { // positions x float64 y float64 // velocities vx float64 vy float64 // get height and width from sheet.xml using sp width int height int } type Enemy struct { Body sp int health int } type Laser struct { Body sp int } type Mode int const ( ModeTitle Mode = iota ModeGame ModeGameOver ) var ( arcadeFont font.Face smallArcadeFont font.Face ) // fonts and sizes func init() { tt, err := truetype.Parse(fonts.ArcadeN_ttf) if err != nil { log.Fatal(err) } const dpi = 72 arcadeFont = truetype.NewFace(tt, &truetype.Options{ Size: fontSize, DPI: dpi, Hinting: font.HintingFull, }) smallArcadeFont = truetype.NewFace(tt, &truetype.Options{ Size: smallFontSize, DPI: dpi, Hinting: font.HintingFull, }) } // in the future have a laser type struct, spriteImgNum, and number of animations type Game struct { mode Mode level int // tracks location of player and maybe health Player struct { Body health int laserType int canShoot bool sp int // consider adding in height and width of player object // all of the sprites seem to be the same // TODO set global width } PLasers []*Laser Enemies []*Enemy ELasers []*Laser gameoverCount int } // load images func init() { // sprites img, _, err := image.Decode(bytes.NewReader(resources.Sprites_png)) if err != nil { log.Fatal(err) } gameImages, _ = ebiten.NewImageFromImage(img, ebiten.FilterDefault) // backgrounds img, _, err = image.Decode(bytes.NewReader(resources.Starfieldreal_jpg)) if err != nil { log.Fatal(err) } bgImage, _ = ebiten.NewImageFromImage(img, ebiten.FilterDefault) } // background image logic from // # https://github.com/hajimehoshi/ebiten/blob/master/examples/infinitescroll/main.go var ( theViewport = &viewport{} ) type viewport struct { x16 int y16 int } func (p *viewport) Move() { w, h := bgImage.Size() maxX16 := w * 16 maxY16 := h * 16 p.x16 += w / 32 p.y16 += h / 32 p.x16 %= maxX16 p.y16 %= maxY16 }

I noticed a similar issue when I got my MBP with the framebuffer not matching the window size and this has to do with the DPI settings. This GitHub link helped me understand the issue better and I hope it can be of assistance to you https://github.com/hajimehoshi/ebiten/pull/1811

This program also demonstrates how great Ebitengine is and how you can port GLSL shaders to it almost 1 to 1.

Basic gist: built in Go with ebitengine, medieval fantasy, pixel art

A Discussion about including this package in Go as encoding/json/v2 has been started on the Go Github project on 2023-10-05. Please provide your feedback there.

I like the Principles section. Very measured and practical approach to releasing new stdlib packages. https://go.dev/blog/randv2#principles

The end of the post they mention that an encoding/json/v2 package is in the works: https://github.com/golang/go/discussions/63397

There used to be the GO FIPS branch :

https://github.com/golang/go/tree/dev.boringcrypto/misc/bori...

But it looks dead.

And it looks like https://github.com/golang-fips/go as well.

I'm not sure what exactly you mean by acknowledgement, but here are some counterexamples:

- A proposal for sum types by a Go team member: https://github.com/golang/go/issues/57644

- The community proposal with some comments from the Go team: https://github.com/golang/go/issues/19412

Here are some excerpts from the latest Go survey [1]:

- "The top responses in the closed-form were learning how to write Go effectively (15%) and the verbosity of error handling (13%)."

- "The most common response mentioned Go’s type system, and often asked specifically for enums, option types, or sum types in Go."

I think the problem is not the lack of will on the part of the Go team, but rather that these issues are not easy to fix in a way that fits the language and doesn't cause too many issues with backwards compatibility.

[1]: https://go.dev/blog/survey2024-h1-results

Now, I’m not going to use C++ again; I left that chapter years ago, and it’s not going to happen. C++ isn’t memory safe and easy to use and would require extended time for developers to adapt. Rust is the new kid on the block, but I’ve heard mixed opinions about its developer experience, and there aren’t many libraries around it yet. LLRD is too new for my taste, but **Go** caught my attention.

Generative AI development has been democratised, thanks to powerful Machine Learning models (specifically Large Language Models such as Claude, Meta's LLama 2, etc.) being exposed by managed platforms/services as API calls. This frees developers from the infrastructure concerns and lets them focus on the core business problems. This also means that developers are free to use the programming language best suited for their solution. Python has typically been the go-to language when it comes to AI/ML solutions, but there is more flexibility in this area. In this post you will see how to leverage the Go programming language to use Vector Databases and techniques such as Retrieval Augmented Generation (RAG) with langchaingo. If you are a Go developer who wants to how to build learn generative AI applications, you are in the right place!

net/http: add methods and path variables to ServeMux patterns Discussion about ServeMux enhancements

Make sure you have Go installed https://go.dev/.