It’s been six months since JetBrains launched a dedicated IDE for Rust. But it’s become a milestone — a symbolic sign that Rust‘s developer community has achieved a new level of maturity.
🚀 Let’s hear it for RustRover – our new dedicated Rust IDE! We’re announcing a free public preview and encourage you to check it out. Enjoy this IntelliJ-based IDE with on-the-fly analysis, code completion, and debugger. Head over to the 👉 https://t.co/egUhhh29Hn
— RustRover, a JetBrains IDE (@rustrover) September 13, 2023
“The state of the community persuaded us that [we] really need it,” Vitaly Bragilevsky, developer advocate for RustRover, told The New Stack in September. And as JetBrains pointed out in their launch announcement, “We are confident that the Rust ecosystem and community will continue to grow. Otherwise we wouldn’t be betting on an IDE.”
Like other JetBrains IDEs, RustRover will eventually become a commercial product — sometime within the next six months — “to ensure our continued sustainability as a team and as a company.” But for now it’s in an Early Access Program. “We at JetBrains believe that making tools for developers should involve listening to them,” explains the RustRover download page,” promising to let the community “influence the development planning, from the early stages onwards.”
So the ongoing development offers a unique perspective on the state of the language — the Rust community, its tooling ecosystem and the language itself.
In February, JetBrains developer advocate Vitaly Bragilevsky shared a surprisingly frank perspective on the podcast of Luca Palmieri (principal engineering consultant at the mobile, web design and development consultancy, Mainmatter). “We are creating tooling. But then we look at the ecosystem and we look at the surveys, and we see that they don’t use that tooling very often — if you look at debuggers, for example.”
While debuggers are an important use case, surveys show that more than half of Rust developers use println! debugging — manually inserting the statements that print out debugging information. But from JetBrains’ perspective, it makes it hard to request additional debugging information from Rust’s compiler team, which could then be supported in JetBrains’ debugging tooling. “The same goes for profiling, for example, about testing — everything.
“So we need to persuade folks to use more tooling and to give us feedback, and to maybe push some other teams out there to make better support for that….”
That’s another unrecognized reality when a major software company produces a dedicated IDE. “With this new product, it is possible to negotiate with all the different folks from the community.” Bragilevsky said on the podcast. “If people start using that tooling more extensively, then that means that we can ask folks from the compiler team to provide more debugging information, for example. And then we can support that information. We can give more to the community in terms of debugging.”
Moment of Maturity
Bragilevsky has just finished his first year as a JetBrains’ developer advocate. He’d been a computer science university lecturer until “Russia invaded Ukraine, and I had to leave Russia,” he said on the podcast. “I was working at JetBrains before that” — in an educational university-level program, “but then JetBrains left Russia, and I left Russia, too.”
Becoming a developer advocate allowed Bragilevsky to switch from education, while retaining his programming-language background.
And it’s an exciting time to be working at JetBrains, as new details keep emerging about ongoing development of the Rust IDE:
- RustRover recently improved its highlighting for type-inference errors, and it will support third-party plugins (including a debugger for programs on the Solana blockchain).
- “Should you want to try RustRover with your existing VS Code settings, you can now easily import them with a single click,” noted the JetBrains blog in February.
- Its official website promises not just code completion, but also code generation, smart refactorings and “on-the-fly analysis” — plus regular updates and timely support.
- There’s also a feature called “live templates,” where short abbreviations are auto-expanded into larger chunks of commonly used code.
RustRover 2023.3 EAP 12 is here🎉! With this build, you’ll enjoy:
🌟 Improved highlighting for type inference errors.
🔧 More Quick Fixes and automatic imports insertion in macro calls.
⌨️ Typing assistance for Cargo.toml right after IDE startup.Details: https://t.co/pwNSkKV4WJ
— RustRover, a JetBrains IDE (@rustrover) March 5, 2024
On the podcast, Bragilevsky said JetBrains had been thinking about Rust for a long time, noting that JetBrains keeps an eye on surveys and levels of language use. For JetBrains, it came down to one question: “Is this ecosystem mature enough so that we can provide something dedicated for this particular community? And of course, decisions like that are not very quick. You need years to analyze everything, and you need years to come up with a decision.”
After watching for years, the moment came: “It looks like Rust’s ecosystem is ready. And we are ready to invest more in it.”
What specifically does that mean? “Looking at numbers, you see that the Rust community is growing, Rust applications are growing and you have a lot of libraries for whatever you want to do. And that means for us that we can enter this market and we can provide a commercial product specifically for Rust developers.
“So for us, we just think that Rust is ready for that. So that’s why we’ve decided to launch that new IDE.”
RustRover will bring the convenience of a bundle with all JetBrains tools for databases, web development and collaboration, Bragilevsky explained. “So, no need to configure something, no need to spend time preparing to work — just download it and open your project and start doing your job. It’s what we usually provide for other programming languages as well — so we bring this experience to the Rust ecosystem.”
But there’s also a larger message. “Having a dedicated project means investing into this particular market. Like, we can hire more developers to work on that. We can start solving problems which we were not solving before because of the lack of resources, right? We can provide more stuff for the developers.”
The Shape of Things to Come
Later in the podcast, Bragilevsky hinted that the IDE could someday visualize the lifecycle of a variable. “We need to find new ways to suggest fixes to users” — maybe even by doing it graphically. This is the kind of thing made possible by a dedicated IDE, Bragilevsky said, “and is not possible when you just talk to the compiler.”
Podcast host Palmieri asked if this was just a concept — or something JetBrains is actually working on. And Bragilevsky responded that they’re not just implementing the Language Server Protocol. “We always say that controlling everything inside the IDE gives you a lot of ways to deliver information to the user. And this gives us much more ways to communicate information, between user, between IDE, compiler, other tooling. So this is what we are working on right now.
“So it’s not something that is just a concept.”
Bragilevsky predicts more good things for Rust in the days to come. “Definitely I see a bright future — otherwise we wouldn’t come into this market.”
But it’s not just an intuition. JetBrains reviews actual data from developer surveys, and “When you look at the surveys, you feel that there is a bright future indeed. Because we see that everything — every piece of the ecosystem — is growing. I don’t see any trends in the reverse direction.”
There’s another observation. When Rust started out, people often talked about Rust as a replacement for “memory unsafe” languages like C++ and C — but Bragilevsky challenges that conventional wisdom. “What we actually see is that there are many folks coming to Rust from other programming languages” — including Python and JavaScript — “and they also bring a whole new universe of ideas to implement something in Rust.”
One example? “I think if we were discussing Rust applications five years ago, speaking about web development would be something really awkward. Like, ‘Well, this is a programming language for system programming, not for some web development, for web frameworks.’ But now it’s a perfectly fine application.”
Bragilevsky predicts we’ll see Rust in more unexpected areas, including medical equipment software, and of course, some really low-level applications at the hardware level. “We have those projects right now, but we don’t have that many commercial applications. But I’m sure that we’ll see something like that.”
What’s attracting people to Rust? Besides its memory safety, and the ability to write more performant software, Bragilevsky thinks that, “For many developers, it’s just big fun to develop something in Rust.
“It’s fun to overcome those complexities. It is fun to come up with memory-efficient implementations. So it is really rewarding to code in Rust.” That also helps get new projects started, Bragilevsky believes — and if you get a good salary to boot, that’s even better.
Bragilevsky expects to see more new projects started in Rust. And it’s not just about rewriting things in Rust. “Folks can just start new things in Rust, new projects — and that’s much easier to do these days. Because we have a mature enough ecosystem.”
But this led their discussion to the question of how programming languages evolve. Bragilevsky has seen languages — including Haskell — become more complicated, but thinks the appetite for that can be limited. “People in the industry? They don’t want to be part of an experiment.”
Palmieri acknowledged that Rust-language proposals like keyword generics seemed to confront a “higher bar” for proving their features justified the added complexity — but Bragilevsky sees this thoughtfulness as a positive trend. “This slowing down is actually a good sign for the industry, that the language is mature enough to be actually used by commercial applications. So they don’t need a language with changes every week.”
Tooling, on the other hand, keeps evolving to serve users. “For the ecosystem, of course it’s very important to grow fast — to provide more libraries to cover more use cases.”
The full presentation can be enjoyed here:
The post The Rust Community Matures with JetBrains’ RustRover IDE appeared first on The New Stack.
It's been six months since JetBrains launched a dedicated IDE for Rust. But it's become a sign that Rust's community has achieved a new level of maturity.
