Hi! As an original creator (and the holder of a dubious title of the maker of the most number of tiny-tiny commits) of both IntelliJ Rust (which turned into Rust Rover) and rust-analyzer I think I can provide some context here! There are going to be several topics here!

First, I believe that proprietary and OSS are good at different things, and that it’s good to have meta competition between the two. Broadly, OSS scales horizontally (you can have many people working together in a weakly coordinated fashion), while proprietary scales vertically (you can get specific things done). It was my explicit nefarious plan to arrange it so that Rust has two competing offerings, one proprietary, and one free, as that’s the best outcome for Rust itself!

In particular, “IDE that understands semantics of the language” is the area where OSS proved to be wholly incompetent, in my opinion. We are living in golden age now, where you mostly can hit “rename” in your editor, and it’ll do proper semantic rename across the project. But it’s important to reflect on how did we get there.

This technology is old, it comes from days well before my first program. It was there at least in 2005: https://martinfowler.com/bliki/PostIntelliJ.html. When I was learning Java in the University, I took things like goto definition, syntax aware selection and smart semantic completion for granted. Heck, I remember relying on completion to muddle through completely inscrutable for me at that time AWT APIs to implement my first ever graphical program (which showed rotated cube).

And well, I was quite shocked to learn later that these kinds of basic features are available only for Java and C#! That was a state of the ecosystem for more than a decade: if you use Java and C#, you get baseline support for editing code. For anything else, you are editing text. Not because editing code is particularly complicated task to do (it’s not trivial, but its not rocket science, well withing the grasp of a highly motivated intern), but simply because collective OSS didn’t get their act together. I am not sure why this didn’t happened, I suspect this is partly due to “real programmers use zcat -” attitude in OSS and partly just due to the large activation energy (it takes a man-year to get to a minimally useful program in this domain).

This changed when Microsoft released LSP, as a natural point of coordination for OSS effort to crystalize around. And I believe the motivation for Microsoft was partly to compete directly with JetBrains, and partly a part of general bet to own all the compute and storage used for software development (LSP certainly makes it easier to move stuff into the cloud).

So, no, left to their own devices OSS seems incapable of crossing refactoring rubicon.

Then, if we think about JetBrains in particular, they seem to be the company that acts with integrity. Which, ok, if someone rejects capitalism and profit motive outright is not telling much, but, if one agrees that there are good companies, JetBrains is certainly one! They are privately owned, not subject to VC pressure, and use the old school model of “you give us money, we give you software”. This model is not perfect! Of course there’s some deadweight loss here as you need to make some parts proprietary, and to invent some feature differentiation. But the alternative isn’t that everything is free: the alternative is that there’s nothing at all, because, to overcome entropy and to accumulate enough activation energy, you actually do need to pay people to write code. And, while JetBrains is a profitable business and they do capture some share of value they create, I think it’s pretty clear that the most value is just dispersed across wider programming community, both in terms of direct “everyone gets to use a top-notch Java IDE for free”, and in terms of actually moving the state of the art in dev tooling and motivating competition. Then, there are smaller things like JetBrains effectively funding my own education (by directly paying the people who taught me, and indirectly by creating a structure where a bunch of experts can actually spend their time on teaching), and very much contributing in this way to my contributions to OSS.

To specific points!

Why not just contribute to the existing open source ecosystem?

Two answers here:

First, IntelliJ Rust was the existing open source ecosystem :-) IntelliJ Rust predates RLS in particular, and I think in general is the first attempt at making a smart Rust IDE. racer predates IntelliJ Rust, but it’s a different kind of thing. I don’t recall the exact timeline of solid oak, eclipse corrosion and eddyb thesis, but I think it’s fair to say that they were at most concurrent, and didn’t go anywhere.

And, to clarify, while Rover is propriatery now, IntelliJ Rust is Apache licensed, and builds on top of Apache licensed IntelliJ Platform. While JetBrains no longer develop IJR, anyone is free to pick the code up and continue to maintain and improve it!

The second answer is that one doesn’t “just contribute to the existing ecosystem” if your vision differs from what’s there in the said ecosystem. The timeline was IJ Rust -> RLS -> rust-analyzer. And rust-analyzer isn’t me contributing to an existing ecosystem. It’s rather that I tried to contribute a feature to RLS, and realized that the easiest way to do that is to just finish my half-written rust parser and slap JSON RPC on top, than to hack on something with, in my opinion, architecture fundamentally mismatched to the shape of the problem. And, to be clear, it wasn’t some secret knowledge squirreled away in my brain, I always was very vocal about how things works in IntelliJ and why that is advantageous.

Because that’s the central bug/feature of OSS: you don’t convince people by arguing about control lof the existing project. You convince people by just going and building stuff, and then showing them the proof-stuffed pudding (or realizing that you were, in fact, wrong).

Finally, super specific: why use JetBrains stuff? The short answer is that because, if you are working on a specific ecosystem well supported by JetBrains, their stuff is just better. While VS Code and IntelliJ have feature parity for basic things, Code doesn’t do anything even moderately advanced. Like, LSP doesn’t have any affordance for interactive refactors, the bread and butter of IJ. And, having used variously Sublime Text, Emacs, VS Code and IntelliJ throughout my career, I must say that the basic editing experience is best in IntelliJ, I find that it just has more polish. Just one case in point: in IJ, you can always focus the editor by double pressing ESC, so you can always get back to coding. In VS Code, I routinely find focus stolen by newton knows what, so that I have to mouse-click to get to actual typing (I use VS Code because I work in several niche ecosystems, and that’s not the use-case well supported by IJ).

Bonus: there’s also a very deep software architecture question: if there are N programming languages, and you want smartness for all of them, do you make N separate language-specific processes which don’t share any code, or do you go the “LLVM for IDEs” style approach, where there’s a single multi-lingual combine? I’ve been thinking about this question for many years, and I don’t know the answer! But IJ is definitely a very interesting and very valuable data point (IJ goes the LLVM way)!

This? I don’t know, what is even the point of a proprietary Rust IDE? Why not just contribute to the existing open source ecosystem?

I don’t really understand your POV. This question seems to sit on the same shelf as those questions:

• What’s the point of releasing a new version of AutoCAD? Why not just contribute to opensource FreeCAD?
• Photoshop? Why don’t they just contribute to GIMP?
• Windows 12? Why don’t they just extend Linux?

Visual Studio is proprietary for a language that is open. Does it make sense for it to support C++?

I have been using JetBrains products for many, many years. I love them. The reason people like me use them is that they are, at least to our tastes, better than the open source offerings. I can’t tell you how many times I’ve been asked how I did something and the answer was “Did what? Do all IDEs not do that?”

Why not just contribute to the existing open source ecosystem? There’s monetizing open source and then there’s just trying to invade an existing open source ecosystem with purely proprietary products for the sake of business.

I don’t mean this as an argument, but for extra context the primary developer of the open source rust-analyzer also led the development of Jetbrain’s Rust IDE features. This makes me think there was a reason the open source rust-analyzer wasn’t integrated, but I agree it’s a shame their new integration is closed.

edit: looks like the plugin was originally open but was made closed when integrated into Rust Rover.

Microsoft’s offerings made sense because they were just maintaining an ecosystem, one could argue it was their duty, or even “right”, if you want to go that far.

That seems a weird argument. Microsoft owns the core of the ecosystem, that seems less of a justification to sell an IDE and developer tooling vs providing it for free to support the platform which makes them the money (And indeed that’s what a lot of their activity has shifted towards), compared to a company which only works on developer tooling.

JetBrains products have always made me uncomfortable

Now I’m wondering when you started using or hearing about them, because when I remember back to the time when they were new and far from being the market leader, they seemed more like this scruffy new kid on the block who just made a solid Java IDE and the people “in the know” used that over eclipse or Netbeans.

Must have been 2005-2007ish? Then at some point they added PHPStorm (maybe 2010?) and I suppose that was when their way to completely dominating the market began.

Also yes, not trying to take away from your point, and it’s not like I have these rose-colored glasses, and in the meantime I’ve had my share of problems with their IDEs, but I can’t forget how much better IDEA was than Eclipse, especially after developing a plugin for it.

Open Source has no direct monetisation that works, and that’s a problem — a vast majority of people only pay for scarce resources, and begging for donations doesn’t work unless you’re Wikimedia.

I understand wanting OSS for the platforms we build on, as it’s important having control. But most developer tools, such as IDEs, are very replaceable, and the value provided is the improved productivity. Obviously, you can use VS Code with its Rust extensions, but many know well that the experience is subpar and Jetbrains’ IDE is currently the gold standard for IDEs.

IntelliJ IDEA Community is Open Source, unlike Visual Studio, and it does a lot out of the box, including full support for Java, Kotlin, Scala. So what Jetbrains is doing is to use the “open core” model. That may not be good enough for many, but I also want them to thrive, as the alternative could be a world without Jetbrains in it.

Why not just contribute to the existing open source ecosystem?

Not everyone has the time or the knowledge to “just contribute” - I’m so close to switching to Goland because vscode+gopls is almost unusable on large codebases, it constantly crashes or runs so slow I have to restart it roughly 10 times daily.

I’d love to “just contribute” to gopls but I just don’t have time, it’s simpler for me to just pay for a quality tool so I can do my job rather than spend hours learning the codebase, finding the bugs, figuring out why they occur, try to fix them, etc. I know some folks enjoy this and I love the OSS community for keeping things like gopls going. I just want to get stuff done rather than messing with my tools constantly.

ReSharper always felt very worthwhile (.. to get my boss to pay for, anyway), but yeah, it fails me to understand using their stuff for Rust.

I don’t know your situation, but I just pay for the “all products” pack. The price goes down each year for the first few years, so at this point I think I pay like $150 per year for access to every JetBrains IDE, of which I regularly use 3-ish. Which seems like a steal, to me.

Ah, good ol’ buy the product or be the product, that makes it even better!

Kinda unfair. Jetbrains doesn’t have any ad-based business, as far as I know. They have a proper legitimate claim to collect usage data, and no part of their business model is predicated on selling user data.

The “evilest” thing I think they can do is use that to try to upsell their tools, like “Oh, you’re using CLion, maybe you wanna buy our rust IDE” or “You have a GitHub plugin installed, wanna try our CI/XD tool?”. And I wouldn’t even be mad about it.

The two answers here are:

• quiet a lot of people work on a single project only! While being able to hop across ecosystem is valuable for some (me included), this is not universal requirement.
• for Rust in particular, Rust+Web stuff is a more popular combo than Rust+C++: base rates are hard to argue with! So existing CLion combo was not meaningful for majority of users.

And the engineering/business historical explanation is that originally there was IJ for Java. I think the first other language was Python, and it was easier to build a separate IDE both technically (it’s easier to make one program with X and one program with Y, than one program with XY if you didn’t start with designing the entire UI around miltipulness) and from the business perspective (if you have a successful product, it’s more reliable to launch a second product than to risk sinking the first product with nominally unrelated features).

To clarify, not saying that the current state makes sense! My comment is descriptive, rather than prescriptive in nature.

People used to have a full C++ and Rust IDE with CLion, and now they have to use two separate programs?

They don’t though? They “just” need to pay for Rust support extra.