Preparing Your JetBrains Plugin for Remote Development
Remote development is reshaping how plugins are built for JetBrains IDEs. Instead of everything running locally, the IDE now splits into a frontend client (what you see) and a backend (the engine), which can be on a different machine, Docker container, or cloud environment. This split mode offers benefits like enhanced security, flexible workflows, and access to powerful remote environments. As a plugin developer, you must think not only about what your plugin does, but also where each part executes. UI and latency-sensitive features need careful design to avoid slowdowns. Below, we answer common questions to help you make your plugin remote development-ready.
What Is Split Mode in JetBrains IDEs?
Split mode refers to the architectural separation of the JetBrains IDE into two distinct processes: a frontend client and a backend server. The frontend handles the user interface—what you see on screen—while the backend performs heavy lifting like code analysis, compilation, and indexing. These two components communicate over a network, which means the backend can run on a remote machine, inside Docker, or in the cloud. This model is increasingly common because it allows developers to use powerful remote environments without sacrificing the local IDE experience. For plugin developers, understanding split mode is crucial because your plugin may need to run partially on the frontend (e.g., UI elements) and partially on the backend (e.g., code inspections). If you design your plugin with this separation in mind from the start, you avoid performance issues and incorrect behavior.
Why Is Remote Development Important for Plugins?
Remote development is important because it enables developers to work with powerful remote servers, improves security by keeping code off local machines, and fosters more flexible workflows (e.g., using standardized environments for teams). For JetBrains IDEs, the split-mode architecture makes these benefits possible. Plugins that are not designed for remote development can suffer from latency or broken functionality, especially in UI interactions, typing-related features, and any element sensitive to network delay. By making your plugin remote development-ready, you ensure it works seamlessly whether the IDE is running locally or in split mode. This broadens your plugin’s compatibility and future-proofs it as more teams adopt remote development workflows. JetBrains recommends that all new plugins be built with split mode in mind, even if you currently only target monolithic IDEs.
How Does Split Mode Affect Plugin Development?
In split mode, a plugin’s code must be correctly partitioned between frontend and backend. UI components (like tool windows, dialogs, and icons) should run on the frontend, while backend tasks (like code analysis, inspections, and indexing) belong on the backend. Shared functionality—such as data models or utility classes—can be placed in a common module. If this separation is ignored, your plugin may work locally but break or become sluggish in a remote setup. For example, a plugin that performs heavy computation in a UI tool window will block the frontend and cause lags. Similarly, a plugin that tries to access the local file system from the backend will fail when the backend is remote. JetBrains provides guidelines to help you restructure your plugin into frontend, backend, and shared modules, ensuring it works in both monolithic and split-mode IDEs without requiring duplicate implementations.
What Is the Recommended Plugin Architecture for Split Mode?
The recommended architecture divides your plugin into three logical parts: frontend, backend, and shared. The frontend module contains all UI-related code—tool windows, dialogs, actions that modify UI state—and runs in the client process. The backend module houses business logic, code analysis, inspections, and communication with the IDE’s core services; it runs in the server process. The shared module includes data transfer objects, enums, and common utilities that both sides need. This separation ensures each piece runs on the correct side, minimizing latency and maximizing performance. Importantly, this structure works in both remote (client-server) and local (monolithic) IDEs. JetBrains offers a plugin template that demonstrates this setup, including proper module definitions and Gradle configurations. Following this architecture from the start saves you from having to refactor later.
What Resources Does JetBrains Provide for Split-Mode Plugins?
JetBrains has prepared several resources to help plugin developers transition to split mode. These include a high-level video overview that explains the concepts, a plugin template with proper module structures and demo features, detailed documentation articles covering terminology, architecture, and a step-by-step guide to splitting your plugin, and a link to the JetBrains Platform forum where you can ask questions and browse existing answers. The documentation walks you through practical steps like structuring modules, moving code to the appropriate side, and connecting frontend to backend. The template serves as a reference implementation you can build upon. These materials are designed to make the splitting process as smooth as possible, whether you are starting a new plugin or adapting an existing one.
How Should I Structure My Plugin Modules for Split Mode?
Your plugin should use a multi-module Gradle project with at least three modules: frontend, backend, and shared. The frontend module depends on shared and includes all UI classes. The backend module also depends on shared and contains business logic and server-side services. The shared module holds common code like DTOs, enums, and utility functions that are safe to use on both sides. In your Gradle build, you define separate artifact outputs for frontend and backend. JetBrains’ plugin template provides a reference structure. Additionally, you need to configure your plugin XML correctly, specifying which components belong to which side. The frontend module should not reference backend classes directly; instead, use communication mechanisms like the remote API or services. This modular approach ensures your plugin runs correctly in both monolithic and split-mode IDEs.
How Can I Run, Debug, and Test My Plugin in Split Mode?
JetBrains documentation explains how to run, debug, and test plugins in split mode. You can launch the IDE in split mode locally for development purposes, which simulates the client-server architecture. Debugging works by attaching a debugger to the frontend or backend process separately. For testing, you can write integration tests that start both sides. The plugin template includes example tests. Key steps include: 1) Starting the backend server (e.g., via a Gradle task), 2) Starting the frontend client connected to that backend, 3) Using breakpoints and logging on each side. You can also test individual modules in isolation. The documentation provides detailed instructions for configuring run configurations in IntelliJ IDEA. It’s recommended to test both in local monolithic mode and in split mode to ensure compatibility. The JetBrains Platform forum is a great place to get help if you encounter issues.