JetBrains Fleet: The future of IDEs?

With distributed and remote options and advanced collaboration capabilities, JetBrains Fleet could be the best thing for software developers since Visual Studio Code. But it’s still in the works.

JetBrains Fleet: The future of IDEs?
At a Glance

JetBrains Fleet is a new multi-language programming editor and IDE that represents JetBrains’ attempt to rebuild the entire integrated development environment from scratch. Fleet is separate from JetBrains’ effort to overhaul the user interfaces and user experiences of its existing IDEs, such as IntelliJ IDEA, without changing the IDEs’ code-centric features and integrations. Fleet will not replace any existing JetBrains IDEs.

JetBrains says Fleet was “built from scratch,” based on its 20 years of experience developing IDEs, and featurs “a distributed IDE architecture and a reimagined UI.” For Java, Fleet uses the IntelliJ code-processing engine. For some other languages, Fleet uses a language server, à la Visual Studio Code, instead of the IntelliJ engine.

I said earlier that Fleet is an editor and IDE. When you start it up, Fleet is a lightweight code editor. Once you’ve loaded a code directory, you can turn on “smart” mode, which indexes your code and enables IDE functionality, such as project and context-aware code completion, navigation to definitions and usages, on-the-fly code quality checks, and quick fixes. Indexing a large project can take awhile.

In many ways, the most direct competitor to Fleet is Visual Studio Code, with its language server architecture and large ecosystem of plugins. Fleet already has a language server architecture, but its plugin architecture is still being developed.

Fleet architecture

Fleet uses a distributed architecture that aims at simplicity of use for standalone instances, while also supporting collaborative development, remote/cloud IDEs, and multiple target file systems.

As shown in Figure 1 below, the Fleet architecture includes:

  • Front end – delivers the UI, parses the files, and provides limited highlighting for supported file types. There can be more than one front end attached to a workspace, allowing for collaborative development.
  • Workspace – the component whose main purpose is maintaining the front ends’ shared state when there are several of them. It also registers other components to provide information on the available services and APIs.
  • Back end – a headless service that does the heavy lifting: indexing, static analysis, advanced search, navigation, and the like. Every such operation is initiated by a request from the workspace, which then processes the response and dispatches the data to the components that require it. As a back end, you can use a headless IntelliJ IDEA or a language server. Note that back ends may have different requirements. For example, language servers need to run on the same machine where the source code is located, as shown in the diagram.
  • FSD (Fleet System Daemon) – a Fleet agent typically attached to the system where source code and SDKs reside. It is used to build the project, run code, execute terminal commands, and perform other actions in the target environment on behalf of Fleet.

Fleet is mainly written in Kotlin, which means it runs on the JVM. The UI framework is a home-grown solution using Skia (via Skiko). Fleet uses Rust for the Fleet System Daemon.

jetbrains fleet 01 IDG

The diagram shows the architecture of Fleet. Multiple front ends correspond to multiple users, and multiple back ends perform different functions. FSD is the Fleet System Daemon, which is an agent used to build the project, run code, and execute terminal commands. IJ is an IntelliJ engine, and LSP is a Language Server Protocol instance.

Fleet language support

Fleet currently supports development in Java, Kotlin, Go, Python, JavaScript, JSON, TypeScript, and Rust. Support for PHP, C++, C#, and HTML will be available “soon.” Fleet doesn’t yet support Scala, Groovy, or any other programming language not mentioned above.

Installing Fleet

Because Fleet is currently in a closed beta, you need to apply for permission to try it out. Once Fleet is ready, which may be some months, it will be opened up to public preview. Once I had permission to join the closed preview, I installed Fleet from the JetBrains Toolbox app on my MacBook Pro.

Fleet smart mode

Smart mode is required for semantic highlighting, code completion, code refactoring, navigation, find usages, and type information retrieval for parameters and expressions. This list is not exhaustive and may vary for different languages and plugins.

According to the documentation, for Fleet’s smart mode features to work, it may need to execute project code, which might pose a problem when its source is untrusted. Actions like importing projects, running scripts, and executing Git commands may run malicious code. For this reason it is important to enable smart mode only when you trust the code authors.

I consider the whole concept of trusting the code authors to be a bit tenuous for open source projects. There have been several egregious cases where trusted, longtime repository maintainers suddenly went rogue for economic or political reasons, with serious consequences for projects that relied on their code. In general, I trust repositories that require code reviews before check-ins are committed, but the level of trust deserved by repositories with a single contributor is often uncertain.

Fleet code intelligence features are provided by components called back ends. Architecturally, they are separate from other components, so they may run both locally or remotely. Fleet identifies two types of back ends, IntelliJ IDEA-based (a headless instance of IntelliJ IDEA with plugins) and LSP-based (a server that talks to Fleet via the Language Server Protocol).

When you enable smart mode, Fleet launches a particular type of back end depending on the language. For example, Java is handled by IntelliJ IDEA, whereas Rust support is provided by a LSP server.

jetbrains fleet 02 IDG

Fleet’s Git integration pane is independent of smart mode. Here we see the summary of repository changes in the left-hand tab, despite seeing that smart mode is off at the top right.

jetbrains fleet 03 IDG

Here we see the progress of a Git pull at the upper right. Smart mode is still off.

jetbrains fleet 04 IDG

Smart mode enables many code analysis functions in Fleet, such as the usage pop-up shown in the middle of the right-hand pane.

Distributed Fleet configurations

Fleet’s architecture is designed to support a range of configurations and workflows. You can run Fleet only on your machine, or move some of the processes elsewhere—for example by locating the code processing in the cloud.

The two distributed options that currently work are using JetBrains Space as the remote environment, and using a remote machine. Future options include running Fleet in one or more Docker containers, and running Fleet in cloud virtual machines.

The IDE to beat

Overall, JetBrains Fleet is very promising, but not yet ready for wide release. It has several ambitious features that could make it a strong competitor to Visual Studio Code, although Visual Studio Code has the advantages of being free, mature, very popular, and widely supported.

JetBrains has been successful in the past in the face of good, free competition. One need only look at IntelliJ IDEA, which managed to carve a niche for itself in the Java/Scala/Groovy world despite the existence of two free, popular, mature alternatives—Eclipse and NetBeans.

Currently, the most desired missing feature in Fleet (for me) is Markdown preview support. The minute Fleet starts to support old-style JetBrains plugins, it will get Markdown preview along with hundreds of other features. Nevertheless, the roadmap for Fleet includes a new plugin architecture. I’m sure there is a good reason for that, having to do with the updated architecture of Fleet, but I expect that support for old-style JetBrains plugins will happen soon for bootstrap purposes.

Cost: Not yet announced.

Platform: Windows, macOS, Linux.

At a Glance
  • JetBrains Fleet has several ambitious features, including a distributed architecture and advanced collaboration capabilities, that could make it a strong competitor to Visual Studio Code. However, Fleet is still under active development and not yet ready for wide release.


    • Functional as an editor and an IDE, with a way to switch between modes
    • Supports eight programming languages now, with four more coming soon
    • Enables advanced collaboration
    • Can be run in distributed mode using JetBrains Space
    • Multiplatform: Windows, macOS, and Linux


    • Still under development
    • Currently has to rebuild its indexes each time you launch an IDE project
    • Doesn’t yet support plugins

Copyright © 2022 IDG Communications, Inc.