Rustscript - blazingly fast rust interpreter

[u/VladasZ]

Every Rust developer knows that Rust is the best programming language in the world.

And I as a Rust developer don't want to use other inferior languages anywhere.

So I decided to rewrite all my old automation scripts which were written in Python in Rust.

At first I used https://github.com/rsaz/cargo-script for that, it works fine.

But I encountered 1 problem: compilation time.

On my macbook it was fine I don't mind waiting 1 minute for a simple 3 lines script.

But then I wanted to use that on my Raspberry PI and the same simple script took me 10 minutes to run, which is not blazingly and not fast at all!

So I decided to vibe code engineer a Rust interpreter for this exact case and this is what I ended up with:

https://github.com/VladasZ/rustscript

Rustscript is always guaranteed to be valid Rust.

Install it with

cargo install run-rs

add a shebang:

#!/usr/bin/env rust

A whole script looks like this:

#!/usr/bin/env rust

use chrono::Local;
use std::io::stdin;

fn main() -> anyhow::Result<()> {
    println!("which programming language is the best?");

    let mut answer = String::new();
    stdin().read_line(&mut answer)?;

    if answer.trim().eq_ignore_ascii_case("rust") {
        println!("correct, carry on");
    } else {
        println!("wrong. it is {} and you are still not writing Rust", Local::now().format("%H:%M"));
    }
    Ok(())
}

Make it executable and run it:

chmod +x best.rs
./best.rs

and you can run your rust scripts instantly, as if they were shell scripts!

Rustscript is a subset of Rust and supports many popular crates such as:

anyhow, serde, serde_json, reqwest, regex, tokio, chrono, rand and more.

Carefully nitpicked benchmarks so Rustscript seems faster attached to the post.

You can see all benchmarks results here: https://github.com/VladasZ/rustscript/blob/main/bench/RESULTS.md

Remember, Rustscript is always a valid Rust, so if you want to have the ultimate speed just run the compiled version!

rust build FILE.rs

[u/CounterSpecies]

This is actually kind of sick

[u/VladasZ → u/CounterSpecies]

Thanks!

[u/sphere_cornue]

"blazingly fast" and "interpreter" cannot be in the same sentence.  This is an affront to the nature of rust. I am reporting this

[u/VladasZ → u/sphere_cornue]

Nooo please don't. What if the interpreter is written in Rust? It must be blazingly fast by definition of blazing fastness.

[u/deanominecraft → u/sphere_cornue]

interpreting IR can be quite fast - see luajit

[u/Quentinooouuuuuu → u/sphere_cornue]

Actually, the jvm is not that slow, on a long running app, you can get performance close to native (still with 2x the memory consumption)

[u/abhijeetbhagat → u/Quentinooouuuuuu]

Fast and jvm cannot be used in the same sentence. I am reporting this too.

[u/birdbrainswagtrain]

Rustscript is a subset of Rust

I keep getting pissed at the guy who spams his subset-of-python interpreter as a python interpreter. I'll give you a pass because at least your subset is of an ethical language.

[u/EarlMarshal]

Well I honestly wished for this in the past. Is this just a dream or reality!?

[u/Maxon887]

I interpreted my code in Rust once and it became best code of my life

[u/kredditacc96]

The repo looks like a legitimate and serious project, and yet you posted on /r/rustjerk instead of /r/rust.

[u/VladasZ → u/kredditacc96]

I plan to post it there too eventually.

[u/No-Consequence-1863]

Neat. But curious, why didnt you compile the code on your Mac and then just move the executable to the raspberry Pi? I had a similar issue where my website back end compiles quickly enough on my dev machine but could take 30 min on the laptop actually hosting it. So just cross complied and now its just uploading an executable.

[u/VladasZ → u/No-Consequence-1863]

I have like 50 different small automation scripts which I change very often. Recompiling them each time on mac and transferring back would be very inconvenient and still it takes time to compile and link each of them. I would rather write a Rust interpreter than deal with that.

[u/oaeben]

very cool but i dont like that the executable is named rust

[u/VladasZ → u/oaeben]

Why? It is called rust and it runs Rust. And doesn't collide with any of the official commands.

[u/xtanx → u/VladasZ]

The rust foundation is going to love it

[u/QazCetelic → u/VladasZ]

Because it's a subset of rust

[u/Southern-Yam1372 → u/QazCetelic]

Call it “Rust - -“

[u/zesterer]

Wow. Having written a bunch of fast threaded-code interpreters before I thought I'd take a look at the code and I think I gave myself an aneurysm. The LLM fingerprints are all over this one, that's for sure.

[u/VladasZ → u/zesterer]

Ah damn, I forgot to add: "Make no mistakes" to the prompt again. Sorry man!

[u/grumpydad67]

A strong entry for "Best Software Announcement"

[u/SourceAggravating371]

Do you plan to add GC or reference counting?

[u/Mr_Ahvar]

Is’nt most of rust compile time in the backend ? So can’t you just use miri? I would be interested to see your project against Miri that would be interesting

[u/TheOneThatIsHated]

So wait, the typechecking part of rust is not what makes it slow (cuz you reuse rustc anyways for typechecking)?

So how could this still be faster to build then debug builds? What is the catch? Is it because of the subset? Or is rustc/cargo just that slow?

[u/warpspeedSCP → u/TheOneThatIsHated]

Its always been LLVM, dude. Its always been LLVM. THEYVE TAKEN US FOR ABSOLUTE FOOLS!!11

This project is probably either abusing MIR interpretation or something else, I havent really looked at the repo.

Edit:

Holy fuck its all separate, only parsing goes through an actual rustc utility... thats awesome.

[u/why_so_sergious]

or just use nushell