bevy

Super easy native wayland support:

[dependencies]
bevy = { version = "0.12", features = ["wayland"] }

godot

Currently, there's no native wayland support. It is at least being worked on:
https://github.com/godotengine/godot-proposals/issues/990

It's big and powerful, but I feel a bit shoved into making a certain kind of game. Additionally, the engine itself is c++ and very complex so it'd be quite hard to make any tweaks to any underlying code.

sdl

There is support, but it's not enabled by default and there are a few bugs.

The most notable one I've been running into is that in your basic hello world example, with wayland enabled, the window will open in tiled mode instead of floating like on x11.

Without any flags windows are meant to be non-resizable in SDL, but they seem to have implemented this by simply ignoring resize requests rather than by setting the min/max size. This was apperantly fixed? but it doesn't seem to work on my machine: https://github.com/libsdl-org/SDL/pull/4065

Ultimately though, maybe this isn't a huge deal? I can't think of any case when you'd actually want the program to be non-resizable. The strange thing is, the cursor is blurry when running with native wayland.

If using SDL, I'd need to pick out a language that makes sense:

hare

• Elegant and simple.
• Tiny userbase, hard to find answers and "ready-made" libraries.
• No windows, macos, or "web" support.
• No LSP and very limited debugging tools.

c

• Simpler than some, but lots of tricky footguns and historic bloat.
• Massive userbase, but not all is high quality.
• Might be meta-useful to have more experience with.
• Great LSPs and build tools.

zig

• Bleeding edge and with various concerning decisions.
• Void doesn't even have a recent build because of it's huge llvm dependency.
• Decent build tools, but fragmented and confusing. These also often require using zig's develop branch.
• Less tutorials and such than you'd expect.

rust

• Huge, slow, and inelegant, but still better than c++.
• Very slow build times.
• Great LSP and dev tools.
• Massive community, tutorials, and libraries.

go

• Elegant and simple.
• Huge userbase and I'm already and expert at the language.
• Great LSP and dev tools.
• Garbage collected. It's a relatively fast one, but still not super ideal and using SDL which is non-garbage collected, feels a bit hacky.

love2d

Supports wayland! However, the mouse cursor is blurry and I'd kinda prefer not to write my games in lua at this point in my life.

raylib

Has experimental wayland support, including the go bindings: https://github.com/gen2brain/raylib-go/issues/24 https://github.com/raysan5/raylib/issues/2666

It's similar to SDL in many ways, but with a much smaller community. Reading through the example code definitely gives me a few concerns about the actual code quality of raylib, but admittedly the examples are super helpful and everything works nicely. I would need to pick a language similar to SDL.

ebitengine

Can't figure out how to get it to support wayland. It's also just not a very big project and I have some concerns about investing time into using it long term.

However, it does use go and does so in a garbage collector friendly manner. It feels very "native" using it with go.