zig-gamedev VS neon

Two game frameworks in the making: https://github.com/michal-z/zig-gamedev & https://github.com/hexops/mach

I did a hangman game, I'm doing a file compression tool next. I asked bing chat to recommend beginner projects for zig and that's what it told me. It also suggested a cli calculator and a cli text editor, but I didn't want to do that. My next thing will be something using https://github.com/michal-z/zig-gamedev

This repo may be useful. It isn't an engine or a renderer, but rather a collection of useful libraries if you do end up writing your own tools. https://github.com/michal-z/zig-gamedev

Something like vulkano in Rust or zig-gamedev in zig might be a much more enjoyable approach: They're similarly bare metal languages but have a lot of advantages over C++ (borrow checker's safety, simpler syntax). However, they're not commonly used by big studios.

I've been working on a gamedev project in zig, using zig-gamedev. It has many libraries you can use, though my game is 2D. Feel free to check out my project if you want to see how I set things up. https://github.com/foxnne/aftersun

Language-level guarantees of memory safety are not critical to all low-level programmers, and sometimes this is fine!

Developers of games, compilers, digital audio workstations, video editors, and live performance software (such as openFrameworks) likely don't rank memory safety as their top concern.

Zig is already an attractive choice for those domains because it offers:

- Great compile times compared to C++/Rust, and future plans to implement hot reloading as a core part of the tooling: https://www.jakubkonka.com/2022/03/16/hcs-zig.html

- The ability to reason about where data exists in memory: https://ziglang.org/documentation/master/#Where-are-the-byte...

- Good readability and learnability, especially if you have a C/C++ background.

- Comptime that enables clean generics, compile-time reflection and general metaprogramming as a happy side-effect: https://kristoff.it/blog/what-is-zig-comptime/

- Better tooling than C/C++. The ability to cross-compile Zig and C/C++ from one machine lets you set up much more stable and reproducible build environments already. You can clone zig-gamedev and have the demos working with just three commands on Windows/macOS/Linux, for example, and two of those three are cloning the repo and changing to the directory: https://github.com/michal-z/zig-gamedev (to build you will need the latest copy of Zig from the 'masters' section for your platform at https://ziglang.org/download/ )

We should all be careful about insinuating that memory unsafe languages should not exist. I see “friends don't let friends use memory-unsafe languages” on social media and feel sick. It's much healthier to embrace the melting pot of Zig, Odin, D, Beef, Vale, Hare, Lobster, Jai, C3, Val, Roc and all the rest and see what new ideas and trade-offs they bring.

Also worth noting that new languages tend to take time to develop their own philosophies to memory safety (Vale's approach is only just now emerging, for example: https://verdagon.dev/blog/making-regions-part-1-human-factor ). Zig's story might not be great now ( https://www.scattered-thoughts.net/writing/how-safe-is-zig/ ), but then it's not Zig's priorty at the moment, and Zig's full story is not yet written.

Great interview!

Love how much thought is being put into what you “gold-plate”. I’ve always felt that my best work comes around on round two (or three or four…).

Curious what you are planning for the ability to script the configuration? I haven’t played with zed much yet; is it possible today? Would something like Neon [1] help bridge the gap from VSCode and old Atom users?

[1]: https://github.com/neon-bindings/neon

Neon

Is there a third option? Surely node has a way to directly call native code, similar to Python's C extensions? Some Node equivalent of PyO3? For example, I found neon which promises "safe and fast native Node.js modules".

Have a look at https://crates.io/crates/napi and https://crates.io/crates/neon which allow you to call rust from node. We went with napi but they're both pretty good.

Just to add: N-API is incredibly underrated. Then again, maybe the lack of a strong native modules ecosystem is an indicator that the pure JS ecosystem is just so good. But man, got something computationally intensive? Just offload it to Rust with Neon or something. Got some proprietary bit of code in your product? Build a native module.

> rust is not well-suited for interfacing with FFI

How so? Packages like neon [1] and rustler [2] suggest otherwise. I'm using both of those in a real product (I'm using neon directly, to write native modules for an Electron app; on the back-end, I depend on an Elixir package that uses rustler).

[1]: https://github.com/neon-bindings/neon

[2]: https://github.com/rusterlium/rustler

You can use https://github.com/infinyon/node-bindgen, https://github.com/neon-bindings/neon, or https://github.com/napi-rs/napi-rs for Node.js libraries, https://github.com/PyO3/pyo3 for Python libraries, https://rustwasm.github.io/wasm-bindgen/ for WebAssembly, and https://github.com/rust-lang/rust-bindgen for C libraries!

They can use Rust to speed up Nodejs through https://crates.io/crates/neon for example

I’m not prompted again while actively using my laptop. When it’s time to switch to an open source project, I’m seamlessly prompted for my GitHub key.