Adapting Your JetBrains Plugin for Remote Development: A Step-by-Step Guide

Introduction

Remote development is reshaping how plugins are built for JetBrains IDEs. In this model, the IDE splits into a frontend client (where the user interacts) and a backend that can run on a remote server, Docker container, or cloud instance. This split mode enables powerful remote environments, enhanced security, and flexible workflows. For plugin developers, it is essential to consider not just what your plugin does, but where each part should execute. Some features—like UI and typing-related actions—may become slow or incorrect if not designed with a client-server architecture. This guide will walk you through making your plugin remote development-ready, ensuring it works seamlessly in both monolithic and split-mode IDEs.

Adapting Your JetBrains Plugin for Remote Development: A Step-by-Step Guide — Source: blog.jetbrains.com

What You Need

Before starting, gather the following materials and prerequisites:

Video Overview – A high-level introduction to split mode (link).
Plugin Template – A reference project showing proper module structures and a demo feature implementation (link).
Documentation – Official articles covering plugin development and a step-by-step splitting guide (link).
JetBrains Platform Forum – A place to ask questions and browse existing answers (link).
Familiarity with JetBrains Plugin Development – Basic knowledge of IntelliJ Platform, module systems, and Gradle.
Development Environment – An IntelliJ-based IDE with the latest version installed.

Step-by-Step Instructions

Step 1: Understand Split Mode Architecture

Start by reviewing the provided video overview and documentation to grasp the split mode concept. Key points:

The IDE runs as two processes: a frontend client and a backend server.
Communication happens over a network, so latency-sensitive features must be handled carefully.
Your plugin should be divided into three categories: frontend (UI), backend (business logic, file access), and shared (models, constants).

Step 2: Structure Your Plugin Modules

Use the plugin template as a reference. Create a multi-module project with a clear separation:

Frontend module – Contains all UI components (tool windows, editors, actions that trigger UI).
Backend module – Houses core logic, data processing, and file-system operations.
Shared module – Holds data models, enums, constants, and interfaces used by both sides.

Update your build.gradle files to reflect this structure. Ensure the frontend module declares a dependency on the shared module, and the backend does the same. Avoid direct dependencies between frontend and backend modules.

Step 3: Move Code to the Appropriate Side

Identify every component in your existing plugin and decide where it belongs:

UI-related code (e.g., tool windows, panels) → frontend module.
Business logic (e.g., analysis, transformations) → backend module.
Data transfer objects (DTOs), commands, and shared constants → shared module.

For typing-related features (e.g., auto-completion, inspections), move the heavy logic to the backend, and keep the frontend as a thin client that sends requests and displays results. If your plugin accesses the file system, ensure those operations run only on the backend.

Step 4: Connect Frontend and Backend

Implement a communication layer between the frontend and backend modules. JetBrains provides built-in mechanisms:

Use remote calls (e.g., via RemoteProcess API) to invoke backend methods from the frontend.
Define commands in the shared module that both sides can interpret.
For real-time updates, consider using connection listeners or a publish-subscribe pattern.

Wire these in your plugin’s startup code. For example, when a user triggers a frontend action, it should send a command to the backend, process it, and return the result to update the UI.

Step 5: Run and Debug in Split Mode

Test your plugin in an environment that simulates remote development. Follow the guide in the documentation:

Launch the IDE backend server on one machine (or Docker container) and connect with a frontend IDE from another.
Use the Run/Debug Configuration to set up both processes.
Attach a debugger to each process to inspect frontend-behavior and backend execution separately.

Pay attention to any performance issues or incorrect UI updates. Adjust your code to ensure low-latency responses.

Step 6: Test for Monolithic Compatibility

Verify that your plugin still works in the traditional monolithic IDE (both frontend and backend running locally). The architecture should degrade gracefully: the same module structure works, but all processes run in one JVM. Run your unit tests and integration tests in both modes to ensure no regressions.

Step 7: Iterate and Refine

Use the JetBrains Platform Forum to ask questions and share your progress. Based on feedback and testing, refine your module boundaries, optimize network calls, and ensure data consistency. Document your architecture for future contributors.

Tips for Success

Start small – Convert one feature at a time, testing thoroughly before moving to the next.
Profile latency – Use built-in profiling tools to identify bottlenecks in remote calls.
Keep the shared module lean – Only include what both sides need; avoid large dependencies.
Mock the remote backend – During frontend development, simulate backend responses to speed up iteration.
Stay updated – JetBrains frequently improves split mode support; follow the platform blog and documentation.
Review community plugins – Look at open-source plugins that have already been adapted to learn best practices.

Tags: