Let’s keep the energy going in 2026. So here’s the new release that was just approved on the marketplace:
New Features:
Dot-Method Completion: GoLand-style method discovery - type obj. to find methods like filter(obj, ...)
Go to Implementation: Ctrl+Alt+B now works for Julia multiple dispatch methods
LSP Status Indicator: Now shows degraded status when the language server is responding slowly
Fixes:
IDE freeze when switching between LanguageServer.jl and JETLS
Duplicate plots appearing in gallery
Clear button not fully clearing plots (old ones would sneak back)
Cross-file navigation failing when target file wasn’t open
LSP status bar showing “Ready” while server was actually unresponsive
Member access navigation (obj.method clicks now properly navigate to method)
So, I focused on seemingly minor issues for this, that required a few more detailed grammar improvements (those are always kinda nasty to fix). The dot-method completion is a big one - typing obj. now discovers all methods that accept that object as first argument, similar to how GoLand handles it. Combined with Go to Implementation support for multiple dispatch, navigating Julia codebases should feel a lot more natural.
Also squashed a bunch of annoying bugs - the IDE freeze when switching language servers was particularly nasty.
I am slowly working on improving the internal reference annotator, so that someday the plugin could work faster without need for the addition of a language server. However, for now it is still smart to just enable it and have it run with merged responses.
Up on my list for the near future: I really found the complaints in the other chat intriguing, so I will spend some time on thinking about ways to improve the experience for all. (Reflections on Developer Experience After Building a Large Julia Codebase - #22 by cuihantao). To me some of these issues derive from how tools were built in the past - all driven by the Julia language perspective and more as peripherals, rather than their own things. So maybe my fresh perspective can make a difference here.
Apart from that: i still want to find ways to improve startup time and indexing time of the Language Server, so I will take another look at the vscode plugin and see if they do something different from what I am doing here.
@PetrKryslUCSD: Thank you for the detailed bug reports - really helped track these down!!! @csvance: Thanks again for your feedback - all addressed in this release .
I’ve just started trying the plugin. I find that finding references already works better out of the box than in VS Code for my specific code base.
One thing I haven’t figured out is a good color scheme. Setting a good scheme seems very hard right now as the different syntax elements are not recognized for Julia (types, function declarations) so everything has the same color more or less. Is this the responsibility of the plugin? Getting something close to the default VS Code colors with the Julia VS Code extension would be good as a starting point to make it easier to switch back and forth.
Thanks! Glad you are already having a good experience.
I agree regarding the color scheme. I am not happy with it either and noticed some elements not properly covered. So yeah, good idea - will take a look at that again!
Maybe I’m doing something wrong here, but even doing something by hand would be impossible as everything basically is an identifier (I changed the color for those to blue and look what happens), instead of some sensible syntax element type:
Flexible Julia being released is quite timely considering its now possible to import PyTorch models into Julia using Reactant.jl. I have a project right now where I needed to do this, so it’s great to be able to work with both Python and Julia in the same IDE. I’m finding that the builtin analysis is similar/better compared to LanguageServer.jl and it doesn’t crash all the time even when it doesn’t work (mostly on extremely large/complex projects with tons of macros like Reactant.jl).
Back to using PyTorch models in Julia, essentially it works like this: nn.Module -> ExportedProgram -> StableHLO -> @compile with Reactant.jl. The resulting model is executed by XLA, so performance is similar to Tensorflow/Jax. The only caveat is the model cannot having any kind of dynamic execution, so things like Dropout can’t be used.
Formatting is finally done right. You now get two formatting options: a fast built-in formatter for everyday use, and the JuliaFormatter.jl integration as an optional implementation . Plus format-on-save for those who like to keep things tidy automatically.
I also worked on dot method completion some more, making an enormous step forward in autocompletion, and on hover documentation.
It was also requested to add a toggle for “compiled debugging” - this is now auto-enabled, but can be disabled via runtime configuration.
@xgdgsc: Thanks for reporting the user-defined type completion issues! @PetrKryslUCSD: Thank you for testing JuliaFormatter integration! @Robin Gerzaguet: Compiled mode toggle and array inspection are on the list!
That’s great! Though I can recommend the ultimate version of PyCharm, Flexible Julia is compatible with the Community Version, too (at least it should - unless I forgot something). The community edition is free and JetBrains offers really big discounts for Researchers and Open Source Contributors- so chances are you may be viable for those as well in case you want to opt into ultimate afterall. Regardless, you will need a Plugin license.
I remember seeing your name in the Julia forum, so here’s an additional discount for you:
XARHF-3Y7F5-MKUJ9-MQS56-DL73P
Use it during the checkout process (there is a field to enter a voucher code on the left).
As for the settings - you can find them all under File - Languages - Julia. Here’s where you can decide on whether or not you want to activate one or the other language server and how their results are merged with the underlying tech.
"""
initSimulation(wf::Union{Nothing, WindFarm}, sim::Sim) -> Union{Nothing, WindFarm}
Initialize or load a wind farm simulation state based on simulation settings.
This function handles the initialization phase of a wind farm simulation by either saving
the current initialized state to disk or loading a previously saved state, depending on
the simulation configuration.
# Arguments
- `wf::Union{Nothing, WindFarm}`: Wind farm object containing the initialized simulation state, or `Nothing` if no state is available. See [`WindFarm`](@ref)
- `sim::Sim`: Simulation configuration object containing initialization settings and file paths. See [`Sim`](@ref)
# Returns
- `wf::Union{Nothing, WindFarm}`: The wind farm state, either the original input state (for "init" mode) or a loaded state from disk (for "load" mode)
# Behavior
The function operates in two modes based on `sim.init`:
## "init" Mode
- Uses the provided wind farm state as-is
- If `sim.save_init_state` is `true`, saves the current state to `"T_init.jld2"` in the specified data directory
- Logs the save operation for user feedback
## "load" Mode
- Attempts to load a previously saved wind farm state from `"T_init.jld2"`
- Falls back to the provided state if loading fails (with warning)
- Handles file I/O errors gracefully
# File Operations
- **Save path**: `\$(sim.path_to_data)/T_init.jld2`
- **Format**: JLD2 binary format for efficient Julia object serialization
- **Error handling**: Loading failures produce warnings but do not halt execution
# Notes
- The function is case-insensitive for the initialization mode string
- File operations use the path specified in `sim.path_to_data`
- Loading errors are caught and logged as warnings, allowing simulation to proceed with the original state
- This mechanism enables reproducible simulations by preserving and reusing initial conditions
"""
Regarding the remote support. It seems to only support one direct accessible host IP instead of something like the jetbrains gateway that parses ~/.ssh/config, which can be mulitple jump hosts in between. Is it possible to use the jetbrains gateway infrastructure? Or is it because this way older linux server hosts could be supported? I could use a port forwarding as a workaround for now.
.
