Interesting, thanks for the explanation, I‘ll check it out. If the LS is not needed, I won‘t insist of course.
1 Like
New Release: Flexible Julia 2025.5.2
New Features:
- Terminal REPL: Migrated to JetBrains terminal panel - feels much more like VSCode now
- Remote Execution: Completely reworked execution logic with experimental multi-file ssh sync
- Smart Project Detection: Automatic Julia project detection now properly resolves context for hover docs, navigation and more
- Standalone Mode: Improved element detection means LanguageServer is no longer a hard dependency
- Package Manager: Added version field, packages now load automatically without manual REPL start
- LSP Installer Dialog: New notification for LSP v1.12+ when modules are missing - includes one-click auto-install
Fixes:
- Remote execution type dropdown missing in REPL
- Wrong LanguageServer starting by default in settings
- Package manager requiring manual REPL start & refresh to show packages
- Functions not loading on hover in certain scenarios
- Lexer breaking on “@.” macro calls
- Stdlib and package resolver issues
- Grammar and highlighting edge cases
- Completion overlay showing duplicate entries
- Minor settings storage bug
We jumped a few versions forward. The remote execution logic now supports multi-file sync over ssh - great for those running Julia on remote servers or clusters. You can now sync and execute entire projects via ssh. Runtime fully integrates into the julia view for the output. Running debug works too, but only does so when a breakpoint is hit (which then integrates into JetBrains debug panel naturally, too - like when running a project locally). The debugger not updating the julia view is a known limitation for now, but I will improve on it in the near future.
REPL is now based on the standard Terminal view from JetBrains, which gives you the original REPL experience. We still added profile selection (your runtimes) and environment selection, so you can use it to execute commands remotely, too.
Remember that unlike REPL the editor view uses the standard JetBrains commands, so CTRL + Space for auto-complete (tab in REPL), hover or CTRL + Q for inline documentation, CTRL + Click for jump-to-source navigation. Also you can select areas in your code and use ALT + SHIFT + ENTER to run it in REPL.
- @PetrKryslUCSD: Thank you again for the thorough bug testing!
- @Satvik: Let me know if you have any issues with this release regarding SSH execution (I will leave a note here, once Jetbrains publishes it)
6 Likes
Version 2025.5.2 has just been approved by JetBrains.
Give it a try - and if you like it, please support the work with a review.
For feature requests or observations, feel free to contact me or drop a note here or on Github - like I said many times before, we are still early in the process and I am eager to hear your thoughts 
UPDATE: I am pulling the version, as I found a critical bug with the LS startup. A new one will be rolled out soon. 5.1 is still available but misses various fixes and the ssh execution, so it is best to wait - sorry everyone.
2 Likes
@madppiper Thank you for this plugin. Unfortunately, I am unable to exploit its full power since I have a LSP:Error in the task bar and I don’t know what to do. The plugin version is 2025.5.2.
Thank you for your help.
Yea, that’s the error mentioned above.
I am updating the plugin as we speak. Sorry about the inconvenience. There is a race condition that breaks the server sometimes.
Update: it’s been uploaded, I am waiting for the marketplace to verify it.
There were multiple causes:
- LanguageServer was crashing when opening a file twice
- SymbolServer can end up in a stale cache state, which can only be resolved by clearing caches (resolved by giving you the option to auto clear caches or manually trigger via menu item)
- our own system did not accurately handle in file cross references (now resolved) - so the fallback had gaps, too.
4 Likes
Just updated, the REPL is feeling so much better now! Looking forward to trying out more functionality.
There are a few things being shown as syntax errors that are valid in the language. Full code can be found here: GitHub - JuliaIO/gRPCClient.jl: A Julia gRPC Client
The + around ProtoBuf.jl:56:
import_cb(io, ctx, definitions) =
mapreduce(x->x isa CodeGenerators.ServiceType ? 1 : 0, +, values(definitions)) > 0 &&
println(io, "import gRPCClient")
<expr>, JuliaTokenType.#=, JuliaTokenType.(, JuliaTokenType.*, JuliaTokenType.->, JuliaTokenType.::, JuliaTokenType.EOL, JuliaTokenType.IMPLICIT_MULTIPLY_SYM, JuliaTokenType.LINE_COMMENT or JuliaTokenType.{ expected, got ','
After the first const around Curl.jl:6:
const CURL_VERSION_STR = unsafe_string(curl_version())
let m = match(r"^libcurl/(\d+\.\d+\.\d+)\b", CURL_VERSION_STR)
m !== nothing || error("unexpected CURL_VERSION_STR value")
curl = m.captures[1]
julia = "$(VERSION.major).$(VERSION.minor)"
const global CURL_VERSION = VersionNumber(curl)
const global USER_AGENT = "curl/$curl julia/$julia"
end
<symbol>, JuliaTokenType.#=, JuliaTokenType.(, JuliaTokenType.EOL, JuliaTokenType.INTERPOLATE or JuliaTokenType.LINE_COMMENT expected, got 'global'
At the first comma around gRPClient.jl:14:
import Base.wait,
Base.reset, Base.notify, Base.isreadable, Base.iswritable, Base.close, Base.open
JuliaTokenType.#=, JuliaTokenType.., JuliaTokenType.:, JuliaTokenType.;, JuliaTokenType.EOL, JuliaTokenType.LINE_COMMENT, JuliaTokenType.as or JuliaTokenType.end expected, got ','
Right after @spawn at Streaming.jl:181
request_task = Threads.@spawn grpc_async_stream_request(req, request)
<assign level operator>, <bitwise level operator>, <comparison level operator>, <multiply level operator>, <pipe level operator>, <plus level operator>, JuliaTokenType.#=, JuliaTokenType.&&, JuliaTokenType.(, JuliaTokenType.*, JuliaTokenType.,, JuliaTokenType.., JuliaTokenType.;, JuliaTokenType.EOL, JuliaTokenType.LINE_COMMENT, JuliaTokenType.end, JuliaTokenType.{ or JuliaTokenType.|| expected, got 'grpc_async_stream_re...'
Another similar one to the above at Unary.jl:179
1 Like
Thanks for reporting. I just updated the 2025.5.3 package again with fixes for all of these and uploaded it to the marketplace.
2 Likes
I just realized that the AI subscription is not needed to enable MCP in Jetbrains IDE for agentic coding. Claude Code will use some of these tools already with the Claude Code plugin. This could potentially blow all other solutions out of the water once the rough edges with parsing/grammar are worked out 
> What MCP tools do you have access to?
● I have access to the following MCP tools:
JetBrains IDE Integration (mcp__jetbrains__)
Integrates with your JetBrains IDE (PyCharm, IntelliJ, etc.):
File Operations:
- get_file_text_by_path - Read file contents
- create_new_file - Create new files
- replace_text_in_file - Find and replace text in files
- reformat_file - Apply code formatting
Search & Navigation:
- find_files_by_name_keyword - Fast file name search
- find_files_by_glob - Find files by glob pattern
- search_in_files_by_text - Search for text across project
- search_in_files_by_regex - Regex search across project
- list_directory_tree - View directory structure
- get_all_open_file_paths - See currently open files
- open_file_in_editor - Open files in IDE
Code Intelligence:
- get_symbol_info - Get documentation/info about symbols at specific positions
- get_file_problems - Analyze files for errors and warnings
- rename_refactoring - Intelligent symbol renaming across project
Project Information:
- get_project_dependencies - List project libraries
- get_project_modules - List project modules
- get_repositories - List VCS roots
Execution:
- execute_run_configuration - Run IDE run configurations
- get_run_configurations - List available run configurations
- execute_terminal_command - Run terminal commands in IDE
- runNotebookCell - Execute Jupyter notebook cells
> Tell me about the grpc_global_handle() function.
⎿ ⧉ Selected 1 lines from src/gRPC.jl in PyCharm
● I'll use the symbol info tool to get details about the grpc_global_handle() function.
● jetbrains - get_symbol_info (MCP)(filePath: "src/gRPC.jl", line: 8, column: 1, projectPath: "/home/csvance/Git/gRPCClient.jl")
⎿ {
"documentation": "**compact function** `grpc_global_handle`\n\ngrpc_global_handle()\n\nReturns the global `gRPCCURL` state which contains a libCURL multi handle. By default all gRPC clients
use this multi in order to ensure that HTTP/2 multiplexing happens where possible."
}
Also I get some additional output when I use a run configuration, not sure if this is to be expected? But that is extremely cool I can also see the variable values after execution.
/home/csvance/.juliaup/bin/julia --project=/home/csvance/Git/gRPCClient.jl -L /tmp/julia_plugin_15997156569627005907/display_hook.jl /home/csvance/Git/gRPCClient.jl/test/runtests.jl
Precompiling packages...
2153.4 ms ✓ gRPCClient
1 dependency successfully precompiled in 2 seconds. 16 already precompiled.
Test Summary: | Pass Total Time
gRPCClient.jl | 1014120 1014120 4.5s
__VAR_START__
__VAR__:TestRequest:DataType:TestRequest
__VAR__:TestResponse:DataType:TestResponse
__VAR__:TestService_TestBidirectionalStreamRPC_Client:typeof(TestService_TestBidirectionalStreamRPC_Client):Main.TestService_TestBidirectionalStreamRPC_Client
__VAR__:TestService_TestClientStreamRPC_Client:typeof(TestService_TestClientStreamRPC_Client):Main.TestService_TestClientStreamRPC_Client
__VAR__:TestService_TestRPC_Client:typeof(TestService_TestRPC_Client):Main.TestService_TestRPC_Client
__VAR__:TestService_TestServerStreamRPC_Client:typeof(TestService_TestServerStreamRPC_Client):Main.TestService_TestServerStreamRPC_Client
__VAR__:_TEST_HOST:String:"localhost"
__VAR__:_TEST_PORT:Int64:8001
__VAR__:_get_test_host:typeof(_get_test_host):Main._get_test_host
__VAR__:_get_test_port:typeof(_get_test_port):Main._get_test_port
__VAR_END__
I can’t get plots or the debugger to work yet. To be honest, I care way more about plots than I do debugger. A working debugger is a nice to have but I have lived without it for my entire time using Julia. Having plots work similar to how they do in Python is way more important.
EDIT:
The plots are inconsistently working for me in run configurations, but never in the REPL. It would also be nice to be able to zoom in similar to how its implemented in PyCharm.
1 Like
I am not sure if people at JetBrains work today (it is a national holiday). So in case you want to check out the latest release with many bugfixes → see update below.
(You can download install it manually via Settings - plugins - install from disk).
It is the version that will become available once they come around to it.
The debugger: You must set it up as a runtime - it works like the usual run/debug config you have. Select a file and debug - let me know if you have any issues there. The Debugger view will then also show the variables.
The plots are probably resolved in the latest release, and so are datatables (at least they should).
Oh and - parsing issues should hopefully be resolved, too…
P.S.: Huge fan of claude here too and yes, I see potential
Update: I think you were right on the debugger. I had focussed so much on the remote debugging feature, I must have broken the regular one. I will fix that for the next release…
1 Like
New Release: Flexible Julia 2025.6.0
New Features:
- Debug Console: Verbose output now shows Julia version, loading status and remote debugger info
- Debug Mode Visualization: Plots, tables, and variables now work while debugging (previously Run mode only)
- Plot Controls: Zoom in/out, fit to window, actual size, plus mouse wheel support
- Native Chart Rendering: Experimental SVG rendering for plots
- Cleaner Console: IDE markers now hidden from output
Fixes:
- Local debugger on Windows (quote stripping was causing issues)
- Display hook now persists plots to a stable temp directory
- IDEDisplay stays at top of display stack in REPL
You can now actually see your plots, tables and variables while stepping through code - which was one of the more frustrating gaps before. The new plot zoom controls should also make inspecting visualizations much easier.
The native SVG endering for Plots.jl is still experimental, but it’s a first step toward better plot integration without relying on external windows (It can be disabled in the Settings).
@PetrKryslUCSD: Thank you again for all the bug testing!
@csvance: Thanks for reporting the debugger issues - and for the zoomable plots idea!
I am not sure if JetBrains are reviewing these today, so here’s the link for anyone who wants to try (install via Settings - Plugins - Install from disk):
https://plugins.jetbrains.com/plugin/download?rel=true&updateId=923377
Happy New Year everyone!!!
5 Likes
Installed the latest and I have to say this is quickly shaping up to be an absolutely incredible option for Julia development! Happy new year!
After new years it would be great if we could also get support for non vector image plots, typically in Julia these have an image/png MIME type. Right now when I try to plot this I just end up seeing a different plot entirely.
Example code:
using Plots
import Downloads, FileIO, ImageIO
path = Downloads.download("http://juliaplots.org/PlotReferenceImages.jl/Plots/pyplot/0.7.0/ref1.png")
img = FileIO.load(path)
display(plot(img))
Example implementation of multiple plotting MIME types I wrote for emacs, maybe its helpful to you:
mutable struct ExportDisplay <: Base.AbstractDisplay
path::String
n::Int64
end
function Base.display(d::ExportDisplay, ::MIME{Symbol("image/png")}, fig)
if !ispath(d.path)
@warn "ExportDisplay: $out_path does not exist"
return
end
file_name = @sprintf "%03d_plot.png" d.n
out_path = joinpath(d.path, file_name)
d.n +=1
save(out_path, fig)
nothing
end
function Base.display(d::ExportDisplay, ::MIME{Symbol("image/svg+xml")}, fig)
if !ispath(d.path)
@warn "ExportDisplay: $out_path does not exist"
return
end
file_name = @sprintf "%03d_plot.svg" d.n
out_path = joinpath(d.path, file_name)
d.n +=1
save(out_path, fig)
nothing
end
function Base.display(d::ExportDisplay, img)
supported = ["image/png", "image/svg+xml"]
for imgtype in supported
if showable(imgtype, img)
display(d, imgtype, img)
return
end
end
throw(MethodError(Base.display, (d, img)))
end
2 Likes
That is incredible - I think i will use that logic. Thanks! And yes - let’s do it for 2026.1.0
Also scheduled for 2026.1.0: sexier charts:
2 Likes
Is this the same thing as this Feature Request: Link plots to code line that made them · Issue #2503 · julia-vscode/julia-vscode · GitHub request? I’ ve implemented it in my branch of vscode before, but the feature got lost after years of code merging. Congratulations for the quick developments!
2 Likes
To me, one of the killer feature of Julia VSCode extension is the ability to run the code line by line (with Shift + enter) and to see the result inline. Is it possible in JetBrains IDEs ?
Just a dummy question. How to test an unregistered version of a plugin in JetBrains IDEs? I have paste the content of thd 2025.0.6 in the right folder, since the IDE recognizes it, but I can’t use it because it can’t find a license attached to this unknown version. Thanks.
(Happy new year to all!)
Well yes. Sorta.
So you have your full debugger - set a breakpoint, set up a runtime config and let it run. Works locally or remotely. It will both fill the julia screen with charts, variables and datatables, but it will also allow you to step over the functions, step by step, see the variables in the jetbrains debugger screen and more.
Then there is also the ALT+SHIFT method of selecting lines of code and sending them to REPL where they will then be executed. Since repl is one big session, you can do the same way like that.
You should download the latest 2025.6.0 release and give it a try and let me know what you think
1 Like
New Release: Flexible Julia 2026.1.0 (available on marketplace)
New Features:
- Julia SDK Manager: Download and manage Julia versions from within JetBrains using juliaup (Tools → Julia → Download Julia SDK or in your Settings → Languages → Julia)
- Better Plot Rendering: Multi mimetype support and much prettier output
- Improved package environment detection
- Minor visual touchups across all components
- ML/AI Documentation: Hover docs for Flux.jl, CUDA.jl, MLJ.jl, and Lux.jl
- Experimental Live Templates: Type “flux”, “cuda”, “mlj”, or “data” to insert common patterns
- Experimental Latex: Unicode math symbols via LaTeX syntax (\alpha → α, \forall → ∀)
Fixes:
- Plot thumbnail layout stability
- Settings panel layout breaking with long SDK paths
So I managed to package this up yesterday and it was already approved by JetBrains. So here’s to a strong start in 2026.
The juliaup integration makes SDK management a lot smoother and after reading some of the posts here, i figured I’d add some convenience functions: hover documentation and live templates for Flux, CUDA, MLJ and Lux and experimental Latex unicode insert.
@csvance: Also implemented your mimetype support - hope that’s what you had in mind. Thanks again for suggesting. Oh and, like I posted above, also made the svg charts prettier.
Everything’s been approved by JetBrains already, so you can download it via the marketplace.
Please keep the feature requests coming:)
@csvance: Thanks for suggesting the improved mimetype support and sharing your code! 
5 Likes
One feature worth adding is dot methods completion like goland, some code reference when the REPL is running.
Judging from various posts like Reflections on Developer Experience After Building a Large Julia Codebase - #14 by cuihantao . Autocompletion and function/method discoverability . Allowing the object.method(args...) syntax as an alias for method(object, args ...) - #218 by xgdgsc . The potential user base can be large.
4 Likes
Interestingly enough, i also looked at that post a few minutes ago. I took a lot of it more of a Julia language concern, rather than one of the available IDEs and he seemed to be working with CLI a lot, too.
He is right though, the features mentioned are definitely worthy to add for the next release. I did implement something like that before the very first release, but it is not working well for me either right now. So I probably need to slightly update my grammar so that they are picked up natively again.
That said, I should definitely look at that thread with more care again, see what else he could have wanted. It is great that he is so outspoken about all that. So perhaps we can throw some ideas around that would help people like him more?
1 Like
I’m able to display image types now! Zooming in and panning also works.
A few issues I noticed:
- Quite often it seems that two plots are generated instead of one for each plotting call (or just doing something like
julia> imgin the REPL). This doesn’t happen 100% of the time, but still more often than not in my experience. - Clear (trash can icon) initially removes the plots from view, but then the next plot most of them come back.
Next I will try and test this with a remote REPL since that is my current main workflow.
2 Likes
Interesting! I will take a look. Thanks for reporting