Building Plugins for JetBrains Remote Development Environments

Introduction: The Shift to Remote Development

JetBrains IDEs are evolving. The traditional model where everything runs on a single local machine is giving way to a client-server architecture. In this setup, the user interacts with a lightweight frontend client, while the backend—compilation, code analysis, and heavy processing—executes on a remote server, a Docker container, or even in the cloud. This paradigm, known as split mode, is becoming essential for modern development workflows. It enables powerful remote environments, enhanced security, and greater flexibility. For plugin developers, this shift brings both challenges and opportunities.

Why Split Mode Matters for Your Plugin

Plugins that work flawlessly in a monolithic IDE might behave unexpectedly in split mode. The reason is simple: the IDE is no longer a single process. Code that assumes everything runs locally—especially user interface logic, typing-related features, and latency-sensitive operations—can become slow or break entirely. To ensure your plugin works correctly, you must consider where each part of your code should run: on the frontend (client side) or on the backend (server side).

The Recommended Architecture: Frontend, Backend, and Shared

The new best practice is to structure your plugin into three logical parts:

• Frontend: Code that handles UI, user interactions, and any operation that requires immediate responsiveness. This runs in the client process.
• Backend: Code for heavyweight tasks like code analysis, indexing, or network calls. This runs on the remote server.
• Shared: Common data models, constants, or utility functions that can be used by both sides without dependency issues.

By designing your plugin this way, it will work in both monolithic and split-mode IDEs. No need to maintain two separate implementations.

Getting Started: Tools and Guidance

JetBrains now provides comprehensive resources to help you build split-mode-ready plugins. These materials guide you through the entire process, from understanding the terminology to deploying and testing.

Video Overview

A high-level video introduction explains the core concepts and motivation behind split mode. Watch it to quickly grasp the big picture before diving into code.

Plugin Template

Use the official plugin template that includes proper module structures and a demo feature implementation. This gives you a rock-solid starting point that follows best practices.

Documentation Articles

In-depth documentation covers the most important aspects of split-mode plugin development. A step-by-step guide walks you through the splitting process: structuring modules, moving code to the appropriate side, and connecting frontend and backend via communication channels.

Community Support

Have questions? The JetBrains Platform forum is where you can ask questions, share experiences, and browse existing answers from the community and JetBrains engineers.

Practical Steps to Make Your Plugin Remote-Ready

1. Assess your current plugin: Identify which parts are UI-heavy, which are backend logic, and which are shared. Look for direct dependencies on local filesystem or network.
2. Restructure your modules: Separate code into frontend, backend, and shared modules following the template structure.
3. Move code to the correct side: Ensure that no frontend code calls backend services synchronously; use asynchronous communication (e.g., AsyncService or LazyService).
4. Test in split mode: Run your plugin with a remote backend to verify performance and behavior. Use the provided debugging and testing guidance.
5. Iterate and optimize: Based on feedback and profiling, refine the split to minimize latency and maintain responsiveness.

Conclusion: Embrace the New Normal

Remote development is not just a trend—it’s the future of how we code. By making your plugin split-mode-ready now, you ensure it delivers a seamless experience whether the user is on a local laptop or connected to a powerful cloud development environment. Start with the resources provided, and you’ll be well on your way to building plugins that are truly built for the modern IDE.