First of all, a big thank you to everyone who joined our Birds of a Feather session at JuliaCon 2026! Even with it being very hot both outside and inside, we were really happy to see so many people show up and join the discussion about the current state of Julia tooling and what is still missing.
The main goal of the session was to discuss tooling that we would like to see in the Julia ecosystem, but that is currently missing, incomplete or difficult to use. We wanted to collect ideas from people working with Julia in different environments and identify areas where better tooling could make development, debugging, profiling, and maintaining Julia applications easier.
We had a number of interesting topics come up during the discussion. We wanted to share them with the wider Julia community and see if there are already projects, approaches, or ideas that we may have missed. Also, if you are already working on any of these problems or would like to start working on one of them, feel free to mention it here.
1. Invalidation Issues
Almost everyone has experienced problems with method invalidations. People want to have better visibility into what is causing invalidations. It would be useful to see which packages cause these issues and get more detailed information about why they occur.
One idea was to provide a visualization of invalidations and their cascading effects, showing which functions are frequently invalidated and how those invalidations propagate. This could also help to identify opportunities to reorder definitions to reduce recompilation time.
2. Type Stable Despecialization
There was interest in tooling for reducing excessive specialization while still maintaining type stability. Overspecialization can lead to increased compilation times and performance issues, and users may not always be aware that this is happening. FunctionWrappers.jl already provides some functionality in this area.
3. Package Trimming for JuliaC
We have also discussed tooling for checking whether packages are compatible with JuliaC and can be successfully trimmed. TrimCheck.jl already provides some functionality for this, but it was mentioned that it is not ideal. One suggestion was to have a dedicated testing framework that could automatically check packages for JuliaC compatibility and identify potential issues.
4. Debugger
Of course, we have also discussed the current state of the debugger for Julia. While there was general agreement that the debugger should be improved, there were no clear ideas yet on what the best approach would be. We would love to hear your thoughts on this, because we believe a good debugger would greatly improve Julia.
What is most important to you in a debugger? Stepping and breakpoints are baseline, but what about memory reading, seeing all active tasks/threads while breaking, or general performance while debugging?
5. Bundle Packages for Easier Deployment
There was interest in tooling that could bundle or “freeze” all the packages and compiled code needed by an application, so it can be deployed and run without requiring recompilation on the target machine. This could make deployment more predictable and reduce startup and compilation time.
6. Monitoring
Someone also showed interest in better observability tooling for Julia, with more metrics and insights into what is happening inside applications at runtime. In particular, having a native OpenTelemetry implementation for Julia could make it easier to integrate Julia applications with existing monitoring and telemetry systems.
7. Equation Syntax
Equations in Julia do not look like the equations we write down on paper. Some people would really like a package that displays mathematical expressions in Julia source code as actual equations, rather than just as plain text syntax. Something similar to how Mathematica presents mathematical expressions was mentioned as an example. This could make Julia code more readable and intuitive, especially for code that closely follows mathematical notation.
8. Onboarding
Getting started with Julia can be difficult for people who are new to the language. This is, of course, not only a problem caused by the lack of (proper) tooling, but it was something that came up during the session, so clearly there is a need for better onboarding. Things like a good debugger could potentially help make the process easier.
9. Slow Loading of Code
At last, there was interest in tooling that can show which files or expressions are responsible for slow code loading times. This could help developers identify the parts of their code or dependencies that are taking the most time to load and provide opportunities for optimization. Tracy.jl was mentioned as already providing some functionality in this area.
Share Your Thoughts
We would love to hear your thoughts on any of these topics! If you know of a package, tool, or existing approach that already addresses one of these problems, please share it here. Likewise, if you have ideas for how any of these could be improved or implemented, we would be very interested in hearing them.
The goal of this discussion is to find out what is already available, where the actual gaps in the Julia ecosystem are, and what tooling could be worth developing further.
And of course, if you have other tooling related problems or ideas that were not discussed during the session, please feel free to share those as well!