JDTLS Rust Proxy by tartarughina · Pull Request #214 · zed-extensions/java

tartarughina · 2026-03-14T22:10:12Z

This PR introduces a new proxy written entirely in Rust.

The proxy sits between Zed and JDTLS, forwarding LSP messages bidirectionally, sorting completion responses by parameter count, and exposing an HTTP server for extension-originated requests.

Motivation

Eliminates the Node.js runtime dependency
771 KB static binary
Faster cold start as no V8 JIT warmup
Lower memory footprint as no garbage collector overhead
~2.5x faster median message processing (benchmarked on Apple Silicon)
Cross-platform — builds for macOS, Linux, and Windows (x86_64 + aarch64)

Other changes included

Add justfile with dev commands (proxy-build, proxy-install, ext-build, fmt, clippy, all)
Add CI/CD workflow that bundles the proxy with each release

Implements a high-performance LSP proxy in Rust to replace the Node.js version, eliminating the 50MB runtime dependency. The proxy forwards LSP messages between Zed and JDTLS while sorting completion items by parameter count. Key improvements: - 2.5x faster message processing (13µs vs 33µs average) - 771KB static binary vs 50MB Node.js runtime - Cross-platform CI builds for all supported architectures - HTTP server for extension requests with 5s timeout - Parent process monitoring to prevent orphaned JDTLS instances

Move Unix and Windows parent monitoring implementations into separate `platform` modules

tartarughina · 2026-03-14T22:14:57Z

Some additional info about the new proxy.

I've been running it for a week on MacOS and on a remote Linux machine without issues.
Windows has been tested as well although feedback for it was minimal, potential blocker.

A comparison between Node and Rust powered by Opus 4.6

LSP Proxy Benchmark: Node.js vs Rust

Overview

This report compares the performance of the existing Node.js LSP proxy (proxy.mjs) against the new native Rust replacement (java-lsp-proxy). Both proxies sit between Zed and JDTLS, forwarding LSP messages bidirectionally, sorting completion responses by parameter count, and exposing an HTTP server for extension-originated requests.

Methodology

Both proxies were instrumented with high-resolution timing (nanosecond on JS via hrtime.bigint(), microsecond on Rust via std::time::Instant)
Benchmarking was gated behind LSP_PROXY_BENCH=1 — zero overhead when disabled
Each message records: direction, LSP method, payload size, and proxy processing overhead in microseconds
Overhead measures only the proxy's own processing time (parse → transform → forward), excluding JDTLS response latency
Tests were run on the same machine (macOS, Apple Silicon) with the same Zed configuration and JDTLS version, performing typical editing workflows: navigation, completions, saves, diagnostics

Test Environment

	Details
Machine	macOS, Apple Silicon (aarch64)
JDTLS	1.57.0-202602261110
Node.js	v24.11.0 (Zed-bundled)
Rust proxy	Release build, 771 KB binary
Zed	Dev extension

Results

Node.js Proxy (3,700 messages)

Direction	Count	Min (µs)	Median (µs)	P95 (µs)	P99 (µs)	Max (µs)	Avg (µs)
client → server	1,399	3	16	81	147	429	28
server → client	2,011	4	24	74	121	4,501	32
server → client (completion)	290	13	50	179	272	458	71
Total	3,700						33

Total overhead: 124,796 µs (~125 ms)

Rust Proxy (5,277 messages)

Direction	Count	Min (µs)	Median (µs)	P95 (µs)	P99 (µs)	Max (µs)	Avg (µs)
client → server	2,093	0	7	32	58	269	10
server → client	2,666	1	8	32	63	1,185	12
server → client (completion)	523	4	17	116	143	253	29
Total	5,277						13

Total overhead: 72,026 µs (~72 ms)

Head-to-Head Comparison (Median)

Direction	Node.js	Rust	Speedup
client → server (passthrough)	16 µs	7 µs	2.3x
server → client (passthrough)	24 µs	8 µs	3.0x
server → client (completion sort)	50 µs	17 µs	2.9x
Overall average	33 µs	13 µs	2.5x

Tail Latency Comparison (P99)

Direction	Node.js	Rust	Improvement
client → server	147 µs	58 µs	2.5x
server → client	121 µs	63 µs	1.9x
server → client (completion sort)	272 µs	143 µs	1.9x

Analysis

The Rust proxy is 2.5x faster on average across all message types
The completion sorting path — which involves full JSON parse, field mutation, and re-serialization — shows a 2.9x improvement at the median (17 µs vs 50 µs)
Tail latency (P99) is ~2x tighter in Rust, meaning more predictable performance
Both proxies add negligible latency compared to JDTLS response times (typically 10-500 ms), so the user-perceived difference is minimal

Personal touch

ONE IS WRITTEN IN RUST (therefore better)

playdohface

This all looks very reasonable to me, and works without issues on my system, including the debugger 🚀
Things that I had on my mind while reviewing this

it might be good to include some way to log from inside the proxy for debugging (I think sending a "window/logMessage" is going to make it show up in Zeds Server Logs). eprintln! will only be shown if we fail to start as far as i can tell
proxy::main could likely benefit from splitting, but for now it's perhaps better as one file, to stay in line with the old one.

proxy/src/main.rs

tartarughina · 2026-03-15T18:17:29Z

it might be good to include some way to log from inside the proxy for debugging (I think sending a "window/logMessage" is going to make it show up in Zeds Server Logs). eprintln! will only be shown if we fail to start as far as i can tell

Ah that's nice, let me include that

proxy::main could likely benefit from splitting, but for now it's perhaps better as one file, to stay in line with the old one.

I was indeed following the old one as a template but we are no longer limited to a single file.

tartarughina · 2026-03-15T18:40:05Z

@playdohface I've added logging following the proposal LSP 3.18 version. DEBUG is for now included with LOG but in case of approval we are ready.

Verified logs emission by checking them under LSP logs --> Server Logs and filtering between the available log levels.

I've also split main into submodules. Let me know if there's something else that could be added

playdohface

Industrial grade logging 👍
Not sure if it needs to be that comprehensive but might as well

proxy/src/main.rs

MrSubidubi · 2026-03-14T23:00:02Z

.github/workflows/release-proxy.yml

+          if [ "${{ matrix.cross }}" = "true" ]; then
+            cross build --release --target ${{ matrix.target }}
+          else
+            cargo build --release --target ${{ matrix.target }}
+          fi


Think there might be something missing here?

~~Something might indeed be off~~ Are you hinting at cross usage? In that case it is required for cross compilation in Linux env for aarch64 support

MrSubidubi · 2026-03-14T23:02:24Z

proxy/src/main.rs

+    // Spawn JDTLS (use shell on Windows for .bat files)
+    let mut cmd = Command::new(bin);
+    cmd.args(child_args)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::inherit());
+
+    #[cfg(windows)]
+    if bin.ends_with(".bat") || bin.ends_with(".cmd") {
+        cmd = Command::new("cmd");
+        cmd.arg("/C")
+            .arg(bin)
+            .args(child_args)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::inherit());


Can we not just conditionallly compile the entire command? Also, are we sure that the command will not spawn a window on Windows? Ref https://github.com/zed-industries/zed/blob/3864b736eaa332f9dbe88831e75242f050a2f699/crates/util/src/command.rs#L13-L25

The additional check for bat or cmd is required in the instance the jdtls launcher is provided by the user.

About the window spawned, I haven't received any feedback about it but I'll try to see if the flag is required.

I did some digging and the flag to prevent a window to be spawned is not required.
The child process will inherit the parent's console. As the proxy itself was spawned without a window the only way for the child to spawn a window would be to override the config.

MrSubidubi · 2026-03-17T00:04:35Z

proxy/Cargo.toml

We could perhaps consider to just make the extension a "proper" Rust workspace? Not sure it is worth it though (or causes some other issues), but might be a bit nicer to work with.

I agree, it is annoying to have two windows open, one with the extension as root and one with the proxy.

Let me see whether the extension will work correctly even with that enabled.

MrSubidubi · 2026-03-17T00:05:48Z

proxy/.cargo/config.toml

Do we need this?

Rust-analyzer without it wasn't able to recognize the active code behind cfg. I'm open to better options. The idea otherwise was to provide all possible values as comment and ask the maintainer to select the proper system.

tartarughina and others added 8 commits March 8, 2026 20:32

Apply format, remove old proxy and add justfile

9c088c6

Add Cargo target for cfg resolution and exe extension when OS is Windows

5cb4116

Fix imports and improve stability of Win path

fecd28d

Refactor platform-specific code into modules

917293a

Move Unix and Windows parent monitoring implementations into separate `platform` modules

Merge branch 'zed-extensions:main' into rust-proxy

af7fadd

Extract platform-specific code into separate module

0863a76

Remove benchmark report from git

e3befe7

tartarughina requested review from MrSubidubi and playdohface March 14, 2026 22:10

cla-bot bot added the cla-signed label Mar 14, 2026

tartarughina added 3 commits March 14, 2026 23:21

Format justfile

76af1c5

Address clippy warnings

6a2e613

Format and clippy fix

8af3427

playdohface reviewed Mar 15, 2026

View reviewed changes

proxy/src/main.rs Outdated Show resolved Hide resolved

tartarughina added 3 commits March 15, 2026 19:19

Remove duplicate method and add LSP logging feature

4c26f3b

Split main.rs into sub-modules

3d3291e

Remove log testing

1a617e5

playdohface reviewed Mar 15, 2026

View reviewed changes

proxy/src/main.rs Show resolved Hide resolved

Restore eprintln

1c845b6

MrSubidubi reviewed Mar 17, 2026

View reviewed changes

Conversation

tartarughina commented Mar 14, 2026

Uh oh!

tartarughina commented Mar 14, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

LSP Proxy Benchmark: Node.js vs Rust

Overview

Methodology

Test Environment

Results

Node.js Proxy (3,700 messages)

Rust Proxy (5,277 messages)

Head-to-Head Comparison (Median)

Tail Latency Comparison (P99)

Analysis

Personal touch

Uh oh!

playdohface left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

tartarughina commented Mar 15, 2026

Uh oh!

tartarughina commented Mar 15, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

playdohface left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

tartarughina Mar 17, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

tartarughina commented Mar 14, 2026 •

edited

Loading

tartarughina commented Mar 15, 2026 •

edited

Loading

tartarughina Mar 17, 2026 •

edited

Loading