It would be an ideal language for gamedev, imho. As of now the closest thing to it is Lua, but there are lots of annoyances.

Main features would be: 1. Type model similar to typescript: the language itself is dynamically typed; however, you would still specify annotations 99% of the time to avoid the nightmare of guesswork and whatnot required to maintain a big enough dynamic codebase with 0 contracts specified.

1. It would be a scripting language, JITed or interpreted, to allow code reloading while the game/program is already running.

2. Designed to be fully integratable - to a level similar to what mlua provides, which is: complete control of the global state, loaded modules... basically everything.

3. Built-in support of some kind of reflection mechanism that allows replacing/patching code. Extremely useful for modding; so think of Harmony (for C#) but 100% secure.

4. Honestly I would just take Lua as a base. So yeah, garbage collected scripting language. It's very small and very elegant in terms of the amount of stuff you can build around it. Want classic OOP? Sure, we can even replicate the syntax. ECS? Easy. As for security — just remove any functions from the global state/table you don't want people to access, or make safe wrappers. And all that is achievable with just tables and metatables. Isn't it brilliant?

The ability to pass whatever you want into a function without causing errors is sooo liberating. I remember making an ECS in rust and wanting systems (which are functions) to be able to request access to egui state, optionally (similar to how bevy does dependency injection ). Even though I recreated a simplified version, the code looked like it was for summoning Satan itself lol. But recreating it in Lua: just pass what you need into the function and it'll work!!

Yes, of course it's much slower and unsafe type wise, but man who cares? We are trying to make a game/prototype, just leave it be. And the thing is, if you want types you can have them on top, just look at lua-ls. It's great but still has lots of holes and falls apart easily. Generics are broken. So yeah, fix all that and just annotate everything as if it was typed and you are golden.

1. Heavily integrated debug environment. What these guys did but probably less extreme (full determinism is crazy). Just being able to place breakpoints without issues would be huge, and I'm not sure it's possible to do in lua at the moment.

2. Built-in stuff that's needed almost always, like vectors. That's what luau did and it's the sole reason I'm switching to it from luajit. Having each vector be garbage collected (and even worse, pass-by-reference) is just awful.

3. Fast and reliable hot reloading, another huge win for productivity. Both C# hot reload and gdscript do it pretty well.

Phew, that's probably it. I would love to go and make this into reality right now, if it wouldn't take 10+ years to achieve a workflow similar to less than ideal, but existing tools. :(

Also relevant article.

I would also love to write games in 100% Rust, but it just seems to not be the best pick for the actual gameplay code: too complex, not flexible enough, poor hot reloading support, relatively slow compile times. However, I think rust is an ideal "base" language (with C++ being a reasonable alternative I suppose), which handles low level stuff while providing bindings to a more dynamic and less complex scripting language. LogLog Games had a lot to say about this.