seems rust's biggest win was improving other languages toolchains and bringing increased productivity to those languages.

▲ retrocog 3 days ago | parent | next [-]

Not a bad win so far, right? One hand washes the other and both wash the face.

▲ giancarlostoro 3 days ago | parent | prev | next [-]

I am waiting for someone to build a modern scripting language in Rust that has the popularity and rich tooling and capabilities of Rust as a result.

▲ ekidd 3 days ago | parent | next [-]

There are two deep capabilities that make Rust, Rust:

1. Banning shared, mutable data. You can't change data that other code might be reading. This is a huge win for threading and multiple CPUs, but it's a dramatic departure from other popular languages.

2. Knowing how data is laid out in memory. This is classic "systems programming" stuff, and it's also present in C, C++, Zed, etc. This usually goes along with making memory allocation visible (though not always in C++). This is a big win for performance.

If you wanted to build a "scripting language" version of Rust, you could probably lose (2). Languages like Haskell are even stricter than Rust, but they hide the details of memory layout. But then you need to decide whether to keep or lose (1). If you keep it, your language will have good threading, but users will need to think about ownership and borrowing. If you lose (1), then your language won't feel very much like Rust.

It would be an interesting intellectual exercise! But actually turning it into a popular scripting language would probably require the same luck and the same 10 years of work that most successful languages need to get real traction.

▲

coolsunglasses 3 days ago | parent [-]

>If you wanted to build a "scripting language" version of Rust, you could probably lose (2).

Not really no. I work on an interpreted language runtime in Rust professionally and it's still a huge help even if you're still eating perf pain on the interpreted language itself for the same reasons everyone else does. There's more benefit to Rust than you're really capturing here but that's to be expected, it's a short comment.

Here are some other things we get from using Rust for interpreted languages:

- The `unsafe` parts are relatively limited in scope and we have much better and more automated verification tools for `unsafe`, especially WRT undefined behavior

- Being able to make large architectural changes and work through them mechanically/quickly because of the type-checking and borrow-checking is absurdly powerful for any project, all the more so in this context.

- The library ecosystem for Rust has been fantastic for all kinds of projects but it's especially good for PL runtimes.

- LLMs are a lot better at Rust than other programming languages. I have a lot of experience using LLMs in a variety of domains and programming languages and it's far better at Rust than anything else that's expressly about programming. Arguably it's even better at Terraform and Ansible but I consider that a different category. Controversial point maybe but I get tremendous yield out of it.

- It's not just that Rust is fast. It is on par w/ C/C++ all else being equal. What's significant here is that it is a _lot_ quicker/easier to hit the 80/20 perf targets as well as the bleeding edge performance frontier in a Rust application than it is in C and C++. A lot of C and C++ projects leave performance on the table either because it's too hard to make the ownership model human-maintainable/correct or because it would be too much work to refactor for the hoped-for perf yield. Not as much an issue in Rust. You can gin up hypothetical perf improvements in Rust with gpt-5 lickety-split and the types/borrowck will catch most problems while the agent is iterating.

Shared, mutable data aren't really banned, we use it strategically in our Rust interpreter, it's just not default-permitted. Aliasing is precisely the distinction between a safe reference and an unsafe pointer in Rust. Aliasing a mutable pointer in Rust isn't UB, it's just `unsafe`. OTOH, aliasing a mutable reference _is_ UB and not allowed in Rust. Miri will catch you if you do this.

On top of all that, you have some nice kit for experimenting with JIT like Cranelift.

	▲	Cyph0n 3 days ago \| parent [-]
		> You can gin up hypothetical perf improvements in Rust with gpt-5 lickety-split and the types/borrowck will catch most problems while the agent is iterating. I am a huge Rust fan, but never really got a chance to write it in the modern LLM era. It makes absolute sense that the borrow checker would make LLM agent-driven refactors easier.

▲ jasonpeacock 3 days ago | parent | prev | next [-]

I just use Rust to do any "scripting" work. I stopped using Python and write it in Rust instead, and I'm more productive than before.

What do you need a scripting language for that's different than using Rust?

▲

Aeolos 3 days ago | parent [-]

How do you deal with slow compilation times?

	▲	jasonpeacock a day ago \| parent [-]
		It's not that slow? Cargo only recompiles the crates that you edit, after the first build of the dependent crates it's quick to iterate. Compilation is not the bottleneck, it's the human (me) in the loop that's doing the thinking and typing. The productivity boost comes from Rust's strong type system and ownership (much better than MyPy) which practically ensures that if it compiles, it will work. There's a lot less troubleshooting/debugging of my Rust "scripts" than when I wrote Python.

▲ librasteve 3 days ago | parent | prev | next [-]

suggest you test drive https://raku.org while you wait (spoiler alert - written in C)

▲ giancarlostoro 3 days ago | parent [-]

I have fiddled with Raku but it feels like a language thats from a parallel universe to Perl which might not get serious adoption. When I look at languages I evaluate them by libraries available for UI, database access, networking libraries and web frameworks primarily.

	▲	librasteve 3 days ago \| parent [-]
		lol Thanks for giving Raku a test drive (https://raku.org) While Raku can access all the perl CPAN modules and Python modules via Inline::Perl5 and Inline::Python, I agree native modules are also a good indication of the level of "adoptability" of a language. I would say that Raku is currently ready for "bleeding edge" and "early-adopters" but not for "early-main" (terms from Crossing the Chasm) For example, there are three pretty nice actively maintained web framework libraries: `- Cro (also HARC stack that uses Cro) - Hummingbird - Web::App` For me the strength of being an early adopter is that the community is small and friendly (with many experts who help me out) and that I can be an influential contributor to shape the ecosystem to do things that meet my needs. And this is not in an ocean of cruft (like CPAN and Python). Similar stories for each of the domains you mention: https://chatgpt.com/share/68c67f75-d654-8009-9c8d-fdb1081869...

▲ testdelacc1 3 days ago | parent | prev [-]

Like Gleam?

	▲	scotty79 3 days ago \| parent \| next [-]
		It doesn't have imperative constructs I think. So half of developers or more are out front the get go.
	▲	giancarlostoro 3 days ago \| parent \| prev [-]
		I was thinking similar but more like a Python or Lua but all in Rust.

▲ ainiriand 3 days ago | parent | prev | next [-]

Do you really think that this is Rust's biggest win or are you just joking/trolling?

▲

IshKebab 3 days ago | parent | next [-]

To be fair it is pretty significant. Especially uv. I don't know anything about PHP's existing toolchain but I do know that Python's is a horrifying mess, and uv basically fixes it.

It's a small thing in the Rust community but it's pretty huge in the world simply because there are so many Python developers (and also because of the extreme magnitude of improvement). Probably wouldn't have happened without Rust.

▲

3eb7988a1663 3 days ago | parent [-]

Thanks to Rust, there are heaps of next generation CLI utilities that have come onto the scene in the past decade. Cross platform by default, UTF8 aware, more likely to be multi-threaded, simple distribution, and most importantly - improving on some unfortunate legacy API decisions.

Ripgrep, fd, tokei, Just, zellij, uv, and so forth. Porting languages has given the opportunity to remove some of the cruft decided on a whim in the 70s. None of these are world changing, but they do make life easier than the originals.

▲

johnisgood 3 days ago | parent [-]

Why is it "thanks to Rust"? They could have been written in any language.

▲

3eb7988a1663 3 days ago | parent | next [-]

To replace a historical C tool, you cannot compromise too much on the original constraints. Replacement has to be equivalently fast and no runtime. Which means even if you made a great design in C#/Java/Python/whatever, that is going to be a deal breaker for some. Safety is (somehow) not a compelling enough argument vs battle-tested.

Rust (or Go) are about the only popular languages around that can meet the spec. That Rust will always be theoretically more performant than GC Go makes it the more attractive option for re-imagining some of these bedrock utilities.

	▲	johnisgood 3 days ago \| parent [-]
		There are actually quite a few viable alternatives to Rust for building these fast toolchains, such as Zig, Odin, OxCaml, and Ada. Granted, not all of them are popular, but that is how Rust started off, too, right? --- Ada would have been great as it is quite mature and used for serious and critical software, but lacks the "cool factor" that Rust has. I would like to add, that there is clearly a disconnect between technical merit and adoption. Ada is a perfect example of this. It has been around since the 1980s with: * Stronger safety guarantees than Rust in many ways (stricter type system, built-in contracts, formal verification support) * Proven track record in safety-critical systems (aerospace, defense, medical devices) * Native compilation with no runtime overhead * Mature toolchain and decades of real-world deployment * ... and much more. If safety was truly the driving factor, Ada should have dominated systems programming decades ago. But it didn't, and that reveals what's really going on. I believe that Rust was chosen over Ada because of: * Timing - arrived when web developers were ready to try systems programming * Community building - excellent documentation, welcoming culture, modern package manager[1] * Aesthetic appeal - syntax familiar to C/Java/JavaScript developers * Marketing narrative - "systems programming without fear", i.e. fuckton of hype Ada had superior safety for decades but lacked the cultural momentum. It was associated with DoD contracts and enterprise software, not cool indie CLI tools. [1] Ada has Alire now as its modern package manager.

▲

Aeolos 3 days ago | parent | prev [-]

Yet they were not - why is that?

	▲	johnisgood 3 days ago \| parent [-]
		Why are you asking me back? I wonder why, too. Now, you can give me a reply for why you think that is, which you could have done without this comment, or you can just keep adding noise to this thread. Up to you.

▲

wavemode 3 days ago | parent | prev | next [-]

I don't think it's strange at all to call this Rust's biggest win. Adopting Rust-based tooling has sped up development and lowered CI costs for millions of JavaScript and Python developers. I can't think of anything else Rust has been used for which has had a larger direct impact on people's everyday lives.

▲

testdelacc1 3 days ago | parent | prev [-]

Not the biggest, but definitely the most visible to people who aren’t dialled into Rust news. For example, many people use Android but they wouldn’t know or need to know that their Bluetooth stack is written in Rust.

Whereas anyone who uses Python would have heard of uv and why it’s much faster than other tools.

▲ smt88 3 days ago | parent | prev [-]

You're wrong because it's also incrementally replacing individual, high-risk components in Windows and Linux.

But even if you're not wrong, a major mission of Rust was to be a safer C/C++, and language tooling used to be dominated by those languages.

▲

tredre3 3 days ago | parent [-]

All the language tools that are being displaced by newer rust replacements were definitely not written in C/C++. They were/are written in the host language (js/java/python/php/ruby).

	▲	tialaramex 3 days ago \| parent [-]
		Which is striking right? Nobody went "Oh, I should write C++ to speed up my Python tool", or if they did we don't know about it because they're still trying to understand the six thousand lines of template spaghetti their compiler spat out due to a typo in one line of their code.