What's new in Ruststudio 0.1.3, and where a Rust-native IDE can go next

Rust Studio — Sat, 07 Nov 2026 06:09:18 +0000

A few weeks ago I introduced Ruststudio, a free IDE for Rust that is itself written in Rust. Version 0.1.3 is out. It is a small release on purpose, so this post covers what changed, a tour of what the IDE does today, and the directions I am thinking about. Where something is an idea and not shipped, I say so.

What is new in 0.1.3

1. Sign-up and sign-in happen inside the app.
Ruststudio is free. After the first week it asks you to sign up, and before 0.1.3 that sent you to a web page and left the app unaware that you had finished. Now a form opens in the window. You enter your details, get a six-digit code by e-mail, type it in, and that copy is linked to your account straight away. There is no password to create. The free-week dialog, the account button and Help > Sign Up / Account all use the same form.

2. Sign out, when you are signed in.
Once your copy is linked, the account menu shows My account and Sign out, not Sign up and Sign in. Sign out asks first, tells the server to unlink this install, and only then clears the signed-in state. If the server cannot be reached you stay signed in, so the app never says "signed out" while the next check quietly signs you back in. Your account is untouched, and you can link again whenever you like.

3. The sign-up dialog no longer flickers.
On Windows, showing a message box runs a nested message loop, and the app's poll timer kept firing inside it, so the "free week is over" dialog opened again on every tick. The fix is a guard plus a test that opens the gate and asserts exactly one dialog. If you hit the flicker in 0.1.2, that is why.

4. Linux downloads carry the version.
The Linux tarball, the .deb and the install folder now include the version number, with a .sha256 next to each, so you can keep several versions side by side and verify what you downloaded.

5. The app trusts your system certificate store.
Some company networks inspect HTTPS with their own root certificate. The update check and sign-up now use the operating system's trust store, so they work there too.

A tour of what is in the IDE today

Editor with rust-analyzer: diagnostics, completion, hover, go to definition, format, Find/Replace, Go to Symbol.
Solutions. A .rssln file lists several projects, a startup project and Debug/Release. A generated workspace Cargo.toml keeps Cargo happy, so nothing about your repository is locked in.
Run menu: build, run, test, clippy, doc, with a Problems panel and an integrated terminal.
Debugger (lldb-dap) with threads and an Immediate window, plus database connectors.
Templates for web (an axum back end with React, Vue, Svelte or Angular), desktop, native Android (no web view), libraries, CLIs, and samples such as a 100k-row data grid.
Packages in one place: crates (including rupm, a registry with revocable tokens), NuGet for native libraries, and npm, pnpm, yarn and bun for the front end.
Cargo Cleaner finds every target folder and cargo cache on the disk and deletes only those.
AI assistant that works with many providers, including local Ollama and LM Studio, using your own keys.

Possibilities I am exploring

These are not shipped. They are what I would like to build next, and I would like to hear which matter to you.

A running-app monitor. CPU, memory and thread count of the program you launched, next to the output panel, so you can see a leak or a runaway loop without leaving the IDE.
Live variable values. Refreshing the variables view at breakpoints and steps, and a light profiler view on top of it.
iOS next to Android. The Android template is native, with no web view. I would like iOS to be native in the same way, with build commands driven from the IDE instead of opening Xcode. That needs a Mac for the build, so it is a separate effort.
Older Linux support. The current .deb is built on a recent Ubuntu, so it needs a recent glibc. Building against an older one would let it install on more distributions.

Try it

Ruststudio is free for Windows, macOS and Linux and installs per user, without administrator rights. On Linux and macOS, install Rust with rustup; the Windows installer can offer to do it for you.

Download: https://www.ruststudio.org

If you try 0.1.3, tell me what is missing. The feedback button in the app goes straight to me.

I ran the same three programs in six languages. Rust did not win all of them.

Rust Studio — Thu, 05 Nov 2026 14:00:26 +0000

"Rust is fast" is true often enough that people stop checking. While building Ruststudio (an IDE for Rust, written in Rust) I wanted a page that tells newcomers when Rust is worth the learning curve, so I measured instead of repeating slogans.

The setup: three small programs, written the same way in Rust, Go, C#, Java, Node and Python. Each prints a checksum, and all six languages print the same one, so they did the same work. Each ran three times at below-normal priority; I report the median. Machine: i7-10750H, 12 logical cores, Windows 11. Rust 1.93, Go 1.26.5, .NET 10, OpenJDK 17, Node 22, Python 3.13. Start-up time is included, so Java and C# pay for starting their runtime.

Speed (seconds, lower is better)

	Rust	Go	C#	Java	Node	Python
Mandelbrot 800x800	0.09	0.09	0.17	0.18	0.15	2.74
Primes below 20 million	0.16	0.18	0.23	0.24	0.26	1.15
Word count, 3 million words	0.81	0.43	0.47	0.55	0.60	1.71

On the two number-crunching programs Rust and Go lead. Python is 30 times slower on the Mandelbrot set.

Now look at the last row. Go and C# beat Rust on the word count, nearly twice as fast. The program creates millions of small strings and looks each one up in a hash map. Rust's default hash map uses an attack-resistant hash, and the program used the system allocator, which loses to the allocators built into Go and .NET for many tiny objects. A fast hasher helped only a little (0.75 s), so most of the cost is allocation. Rust gives you the control to fix that (reuse buffers, avoid the allocation, choose another allocator). It does not do it for you.

Memory (peak MB)

	Rust	Go	C#	Java	Node	Python
Mandelbrot	3.9	5.6	21.0	38.0	30.7	10.7
Primes	23.0	25.5	39.6	55.8	47.9	48.8
Word count	8.0	13.0	35.3	99.1	49.5	16.2

Rust used the least in all three. There is no garbage collector, so memory comes back when a value goes out of scope.

What you ship

The Rust benchmark became one 146 KB executable that needs nothing installed. Go: 2.4 MB, also standalone. C# and Java need their runtimes; Node and Python need the interpreter and their packages.

The bugs that never run

I wrote the same small bug in each language. A missing value used as if present, use after move, a reference that outlives its target: in Rust all three are compile errors. In every other language the first one crashes at run time.

The one that surprised me: eight threads adding to one counter with no lock. Rust refuses to compile it. Go printed 244,043, C# 207,098 and Java 117,040, where the right answer is 800,000. No error, and a different wrong total each time. (Node is single threaded, and Python's global lock happened to hide it in my run. That is luck, not a guarantee.)

What Rust costs

It is wordier: 83 lines against Python's 41. Release builds compile slower. Ownership takes weeks to feel natural. Some ecosystems (mature GUI toolkits, enterprise libraries) are thinner than Java's or .NET's. And integer overflow is not stopped: a release build wraps like everyone else's.

So when?

Choose Rust when a crash or a security hole is expensive, when you need predictable latency without GC pauses, when you want one small executable, or when the code will live for years. Choose something else for throw-away scripts, or when your team already ships fast Java or .NET and the hot path is not critical.

Everything here is regenerated by scripts. The full write-up, with the bug table and the method, is at https://ruststudio.org/why-rust. These are small programs on one PC: an illustration of trade-offs, not a verdict. If you think a program is unfair to your favourite language, send a fix.

DEV Community: Rust Studio