[airstrike]

> Roto fills this niche for us. In short, it's a statically typed, JIT compiled, hot-reloadable, embedded scripting language. To get good performance, Roto scripts are compiled to machine code at runtime with the cranelift compiler backend.

Statically typed, hot reloadable scripting? Sign me up.

[echelon]

I have dreamed of this for Rust. It is literally _the_ killer app to have a fast scripting language that pairs with Rust well.

With fast development cycles and a safe scripting language, Rust will find itself in every single programming niche. Server development, game development, desktop application development. If the WASM DOM bridge gets better, maybe even web development. Everything will open up.

You can prototype in the scripting language, write mature application logic in the scripting language, and for the parts that matter, move them to Rust.

I hope Roto can be that. There are lots of other Rust scripting languages that fall short.

A good scripting language will have great Rust interop, similar syntax, and allow simple calling and passing of data structures. It shouldn't weaken Rust in any way.

[falcor84]

> game development

I've been out of the loop for a while, but last I checked, the running gag was that there are more game engines written in rust than games. Have things changed? Any high profile games that were made in rust?

[lunyaskye]

The biggest one I know of is Tiny Glade: https://store.steampowered.com/app/2198150/Tiny_Glade/

It's mostly a custom stack, but it's written in Rust and uses some parts of Bevy from what I understand.

[kurayashi]

Afaik there still no high profile games in rust. But many if the complaints I’ve read of devs switching back from rust were about how hard it was to prototype something in rust. Having a scripting language with solid rust interop could help.

[dkarl]

We keep saying "scripting language," but given that it's statically typed and JIT compiled, we could also call it an "application language." Relative to Rust, most backend applications can afford to trade off a little bit of performance for better development speed and readability.

[airstrike]

VBA but good

[sn9]

This might be revealing my ignorance, but if we're going for statically typed "scripting languages", why not implement an ML like SML?

[cess11]

What does Rust have that other languages with these properties don't?

[mikepurvis]

On the game engine side, probably not a lot until there's more ecosystem built up, but across the board you could look at the niches filled by the Java/Groovy and C/Lua pairings to get a pretty good sense of what's possible— it would be the tools stuff that would most excite me: build/CI/automation frameworks, that kind of thing.

Alternatively, look at a project like ruff— hundreds of linter rules statically implemented in native Rust [1], maybe that would make more sense if the rules could be more tersely expressed as runtime-loadable roto scripts that have access to the Python AST and a toolkit of Rust-supplied functions for manipulating and inspecting it?

[1]: https://github.com/astral-sh/ruff/tree/main/crates/ruff_lint...

[cess11]

So no clear examples?

[mikepurvis]

In the Java/Groovy space, Jenkins and Gradle are the obvious ones.

I'm less familiar with the Lua world (not a gamedev), but this is an example of the kind of thing I'm imagining— a build system / task runner that's half lua and half C/C++: https://github.com/xmake-io

Having a modern on-prem replacement for Jenkins/Rundeck built in rust and exposing a roto interface rather than yaml definitions sounds like it would be great.

[cess11]

So, how is Rust better than these? What does it have that these lack?

[echelon]

- The best package manager in the world, bar none. Compiling, linking, and platform difficulties disappear. The devops/devexp is next-level sublime.

- "low defect" software without much work. I'm not talking about memory management, but rather Option<T> and Result<T,E>. For the same amount of effort as writing Golang or Java or C#, you can get defect free code.

- Easy deployable to WASM without packaging a memory management runtime for the most intrusive types. Super portable, super fast.

- If you've used Unreal a lot, you've hit build issues, linker issues, segfault issues. A lot. That'll go away.

[xlii]

> The best package manager in the world, bar none. Compiling, linking, and platform difficulties disappear. The devops/devexp is next-level sublime.

I don’t know how are universes split but I’m in the wrong one for sure!

300Gb compile caches, 5 minute compilation, nix flakes with layer and careful adjustments for different arch and deployments, cargo slowing builds by 5 minutes every time because it insist on downloading full repo every time (and occasionally failing). API libraries maintained by some completely anonymous guy or lad from eastern country.

On top of it the bugs don’t get away. If your problem IS memory safety, then sure - chomp away. But I’ve seen u64 truncated to u32 because someone decided to thread it through JSON serialization and macro soup.

Every bear looks like a puppy when it’s a cub.

[cess11]

Java 8 was released in 2014, since then Optional is in the standard library and a rather common pattern. Like Rust you can use LLVM to compile Java to WASM (JWebAssembly), and there's also TeaVM for turning a project into an optimised WASM application and CheerpJ for running a JVM in WASM.

It was rather messy to use cargo on handheld ARM, it didn't spark joy so I kind of stopped trying after a while. Mostly I use Rust as a dependency I don't need to touch, but when I've programmed in it I didn't feel like cargo was that big of a thing. Maybe I would feel another way if the frame of reference was only like webpack or Pip or something.

[CooCooCaCha]

It’s also a pleasant language to work in. I love that everything is an expression, I love match statements, I love that structs and enums are full powered, etc.

[mdaniel]

> It’s also a pleasant language to work in

I know, practically self-documenting code!

https://github.com/tokio-rs/tokio/blob/tokio-1.45.0/examples...

I'm not trying to pick on tokio, it was just a public link demonstrating that the syntax can get to be a bit much

[CooCooCaCha]

Of all the examples of crazy Rust code you could have picked, you chose that one?

Is adding ‘a really too much for you?

[speed_spread]

Then also have a look at Mun:

https://github.com/mun-lang/mun

- Ahead of time compilation

- Statically typed

- First class hot-reloading

Not sure how both languages compare though

[terts]

Hi! Author here. Mun is super cool, but works slightly differently as far as I know. You compile Mun scripts outside of your application to a dynamic library, which can then be (re)loaded by your application. The advantage of that approach is that you can ship the compiled script with your application.

The downside is that it's not really possible to share types between the host application and the script as far as I know. They have something called called `StructRef` which does this a bit, but it's all runtime checks if I understand correctly.

If somebody here knows more about Mun, I'd be happy to be corrected. This is just my understanding from their documentation.