Where is Julia heading? Lack of clarity about priorities, long-term direction and governance

Community
,
1

I’ve been increasingly wondering: where is Julia actually heading?

As someone trying to evaluate Julia for long-term or industrial projects, it’s quite difficult to understand the language’s broader direction — both technically and strategically. I’m genuinely interested in seeing what areas are being prioritized and what kind of roadmap the community or core team envisions.

Some specific examples of what I’d personally like to understand better but feel free to add something in the comments:

  • Is static compilation a current priority? If so, where can I read more about ongoing work or plans?
  • Are there efforts to improve startup times or general execution performance ? Maybe only startup times? Maybe only execution performance?
  • Is binary size reduction being actively pursued? Or not?
  • What’s the status or plan for developer tooling — e.g., the Language Server, debugging tools, IDE support, etc.? I’ve head something about new LS, but what about new debugger?

These are all crucial aspects for many of us trying to decide whether Julia is the right tool for multi-year projects. It’s not just about current capabilities — it’s about knowing what’s likely to improve, what’s on hold, and what’s not on the radar.

Right now, it’s very difficult to find that kind of information. For instance:

  • Discussions like this one are dead
  • Other threads (like roadmap for small binaries) focus on specific issues, but not the general direction.
  • Searching “Julia programming language roadmap” on Google doesn’t show anything useful IMO
  • Searching “roadmap” on Discourse yields old scattered topics that are outdated

For industrial or long-term use, the absence of a clear public roadmap (which is up to date) makes planning challenging. If some issues are known and scheduled for attention (say, next year), that’s fine — but without any visibility, it’s impossible to know whether a particular area is a priority or simply not on the radar.

For comparison, other language communities have clear and centralized ways to communicate their development direction. For example, Python has the PEP process, where major changes and long-term visions are publicly discussed and documented. Rust maintains an openly accessible roadmap through RFCs and annual planning discussions. Go has its proposal process and blog posts outlining key upcoming work. Swift publishes detailed evolution proposals and focus areas that let the community understand what’s under consideration. C++ operates through ISO committee papers and regularly publishes C++ standardization roadmaps that outline what features are targeted for upcoming standards (C++23, C++26, etc.). In the JavaScript ecosystem, the TC39 committee maintains TC39 activities where new language features can be tracked from idea to standardization. These models make it easier for developers and companies to align their plans and expectations with the language’s future.

Is there an official or semi-official way to track this? I also tried ChatGPT and Claude with search feature and the response was somewhat like

The Julia community does not appear to provide a consolidated, clearly communicated official roadmap document that states “Next year: X; in 2 years: Y; in 5 years: Z”.

Claude suggested me to learn about it through JuliaCon talks or GitHub discussions. If that is the only way, that’s quite scattered and difficult to follow. JuliaCon talks don’t have a lot of discussions and I doubt the comments on YouTube influence the decisions of the core developers. GitHub discussions are overloaded with technical jargon. E.g. this issue on milestone for Julia 1.13 and I have absolutely no idea what it is about. Does it make language better? Maybe. Does it make more clear where Julia is heading to. Absolutely not.

I also occasionally encounter extremely frustrating discussions on GitHub — for example, one issue reports clear regressions in pre-compilation times yet appears to have been closed (thankfully reopened) without any public rationale as not planned. Beyond the absence of a clear agenda, I’m left asking: who is making the decisions, on what basis, and why are significant (imo) issues closed as “not planned” without explanation? This lack of visible governance undermines my personal trust in the project’s direction.

Would it make sense to have something like a Julia Roadmap dedicated website or even a PEP-style process to document directions, discussions, and rationales for major language or tooling initiatives? That kind of structure would make Julia more predictable and transparent — and much more attractive to organizations planning multi-year adoption.

17 Likes
2

Hi @bvdmitri , it is good to see you here. Welcome to the club of industry professionals who are not happy with the lack of clarity and governance model of the language. I raised this issue multiple times in the past and got out of the discussion with no clear roadmap. You will probably get a lot of replies (e.g., “this is open source…”, “there are not enough volunteers”) and other excuses, but hardly a definite answer.

You are not alone.

4 Likes
3

There are about 75 individuals in the triage team who can close, open, label and tag issues on the issue tracker. Any one of them can take action — based on their own best understanding — what to do with any particular issue.

There are about 50 individuals with commit rights — the folks that can merge PRs themselves.

There are a handful that meet biweekly to try and unwedge issues that are complicated or that folks aren’t fully agreement on.

All of our individual motivations and priorities vary, but everyone tries to move through consensus. In many cases, the PRs themselves serve as the “enhancement proposal,” but for very large things folks have first collaborated on hackmd — for example Memory or Pkg Applications. Milestones typically represent release blockers and are more internal organizational tools than high-level goals.

So, yes, this is a ship being steered by lots of people, all trying to work together to chart a good path to improve things for everyone.

It’s far easier to talk about what a particular person (or group of people in the same company or org) are doing, but that is not the whole of the project. To see what JuliaHub is doing (I am a JuliaHubber), this recent post from July is very good:

5 Likes
4

Three things come to mind:

  1. The newsletters:
    This month in Julia world - 2025-09

  2. The last State of Julia talk. Here’s State of Julia 2025 at Pittsburgh with given by @Lilith and @Keno . The slides are also available.

  3. Someone did start a Juleps repository that would be the equivalent of PEPs: GitHub - JuliaLang/Juleps: Julia Enhancement Proposals

8 Likes
5

I think this screenshot from the State of Julia talk kind of reinforces the point made in the original post

image
image1822×1021 329 KB

6 Likes
6

Keno’s post from about a year ago here also includes a good description of the status quo and tensions therein.

I should add that my post above is aiming to be descriptive, not prescriptive… and I think the same is true of Keno’s there too.

3 Likes
7

How does other programming language manage to have clearer roadmaps and what can the Julia community learn from them?
I haven’t look at the roadmaps of other languages myself, but I see that people are regularly stating that they are more transparent.

5 Likes
8

I think that’s exactly the point: often it feels like there is no unified direction that everyone seems to be pulling in, and it’s kind of unclear when any given effort by an individual towards some thing fizzles out. Reaction instead of Action, and that sort of thing..

With JuliaCon talks & Github discussions it’s somewhat easy to know retroactively what happened, but that doesn’t make it easier to know where we’re going.

8 Likes
9

Thanks for taking the time to respond but I feel your reply misses the core issue. My point was not that the work and plans for Julia don’t exist at all — clearly they do. The trouble is that there is no single, centralized place where the language’s broader roadmap, priorities, governance structure and decision-making rationale are communicated clearly. Instead, the information is scattered across videos, issues, discussions. A spherical employee in vacuum cannot just go to their managers and tell them “lets use Julia” because the next question will be “where Julia is heading in next 5 years”.

If I go to the official Julia website I see the following statement

Even though there’s no formal connection between the company and the open source project, JuliaHub is deeply committed to Julia’s success and is proud to sponsor JuliaCon each year as well as drive open source Julia development.

No offence, but the post you linked appears (a) to be more of an advertisement for a product and (b) to contradict the statement on the governance page—implying a formal/direct connection. So I’m left asking: is the implication that Julia’s direction is primarily driven by a commercial entity (in contrast to what is written) and that decisions are made primarily to serve a specific product or business rather than a broader community?

I don’t object to commercial influence and in fact, I’m fine with it if it’s made transparent. What I do object to is the lack of clarity around that relationship (though the post you linked clarifies it):

  • Are we saying Julia is effectively a product of JuliaHub and that community input is secondary if it doesn’t align with business goals?
  • To use a contrasting example from Python community - Mojo - the community knows it is a commercial endeavour — that’s explicitly stated, so expectations are clear.

Even if Julia is heavily influenced by commercial needs (e.g., via salaries of core developers or funding from a company), a public, centralized roadmap would still be extremely beneficial for companies or projects trying to plan ahead. It is very normal to have Python core developers on salaries from Google or Amazon or Apple, the agenda and plan still exists and is clearly communicated.

Nice to see you here @mkitti

The newsletters:

Same reply as from @Sukera

With JuliaCon talks & Github discussions it’s somewhat easy to know retroactively what happened, but that doesn’t make it easier to know where we’re going.

The last State of Julia talk

I mentioned in my post that its difficult to follow in the video format + as noted by @Wouter_Nuijten it is actually reinforces the entire point and clearly states there is no centralized plan.

Someone did start a Juleps repository that would be the equivalent of PEPs

But that repo is 5 years long outdated… that is again reinforces my point. Also, anyone on the internet can start their own PEPs. It doesn’t make sense unless it is made official.

4 Likes
10

The State of Julia talk actually makes it very clear that there is no centralized plan and sort of answers my question. Unless there any other updates (that are hard to find too)

3 Likes
11

Whoa, I did a terrible job of communicating there. No, that’s not at all what I was trying to communicate! I’m saying that JuliaHub is one of many orgs that has a vested interest in Julia’s direction and employs a number of individuals with commit rights. But our priorities are just one voice amongst many. And in fact, even within JuliaHub, there are many priorities being balanced. In fact, even within myself, I balance my work priorities and personal desires for the language.

Note that this isn’t about dictating who works on what, but rather what changes are accepted. The former either requires economics or goodwill donations, whereas the latter is actually about the direction of the project. They’re highly entangled, though, which makes it challenging.

3 Likes
12

Also, I feel like I should explain what do I mean by “clearly communicated”. Obviously, clarity is somewhat subjective; what seems clear to one person may feel opaque to another. However, other language communities have formalized proposal processes—and the Juleps repository (shared by @mkitti) is a very good illustration of what clear documentation could look like. For example, the “Pkg3” proposal lays out the motivation, design-rationale, history, and architecture for the next-generation package manager in a structured way. Super nice to read while it is now very outdated (dating from 2016). Its format nevertheless demonstrates how a proposal can communicate direction, reasoning and future paths transparently. The one about Memory shared by @mbauman is also very good, but I would never find it myself I think.

4 Likes
13

The two forward looking slides in the State of Julia were as follows:

image
image1215×682 220 KB

image
image1208×677 40.3 KB

It seems hard to answer the question if there is a single plan for the entire community as a very distributed open source project. It does seem possible to ask specific entities, sometimes individuals, what are they planning in the near future.

  • What is JuliaHub working on for Julia?
  • What is the next step for Relational.ai with regard to Julia garbage collection?
  • What is @tecosaur (Timothy) planning for the Paths JULEP?

Of the four “In the works” points above, what strikes me is that one of them is clearly not JuliaHub led. The garbage collection direction had been motiviated and led by Relational.ai over many years.

image
image1208×677 40.2 KB

One of the first questions I had about Julia was how hard would it be for me to submit a pull request to the core language. The answer was about two months from starting to use the langauge to making a change. A fair number of pull requests still seem to be coming from “3rd parties”, so it seems hard to read all of their minds.

One way that I found to learn about direction and controversies in the language is by attending the Julia triage meetings. In the triage meetings, triaged pull requests are discussed. This is where I first learned about the Memory discussion. Perhaps it would be good for someone (or something) to take and publish notes of that meeting. I think it would quite illuminating to share what is being discussed there.

My overall sense is that the information is obtainable and that we certainly could use more volunteers like @Krastanov who gather information and summarize what is being discussed as a community.

10 Likes
14

You can find many such documents by just looking through the pull requests and issues for references to hackmd. But even in the absence of such an external document, large pull requests (and sometimes issues) often typically include very similar content. For example, one of the thoughts Keno speculated about in the state of the union address is syntax evolution and export versioning. Here are the two drafts PRs he recently opened:

So: are those priorities? Are they on the roadmap? Will Keno keep working on them? Will they be accepted? Is it even something that the consensus wants here? I personally have no idea. And therein lies the challenge.

1 Like
15

As a practical matter, if Julia (or any tool) doesn’t already do what you need (at the level you need it) then you should strongly consider other options. Pinning your project’s success on any future roadmap – to be fulfilled as you imagine and on your needed timeline – is a risky proposition.

Occasionally, someone drops an awesome new feature (either in a major release or a neat package) and occasionally it even helps one of my projects. But I view that as a surprise gift. I don’t start a project unless I can complete it with what’s already available. This hasn’t been much of a blocker for me with Julia, personally.

10 Likes
16

Has this actually happened? Or is it a hypothetical? At any rate, Here is how I would address this if a manager of mine asked me this.

The only question that matters is, is Julia the right tool for the current problem right now? If it is, then let’s use it. If it is not, then we need to pick something else.

I don’t think its more complicated than that in all honesty. Pick the right tool for the job and be done with it.

I 100% agree with @mikmoore who wrote his post much faster than me and beat me to the punch. :laughing:

7 Likes
17

Oh hello :waving_hand:. Since I’ve been invoked, I’ll draw people’s attention to the fact that if you scroll down to the latest messages you’ll see it’s far from abandoned, just being slowly mulled over.

I plan on continuing work on both the proposal and implementation, until it gets to a point I feel really good about.

p.s. if anybody else is interested in this work, I’m very keen to talk through ideas with other people/play around with implementations.

2 Likes
18

The two forward looking slides in the State of Julia were as follows:

Those second slide has nothing to do with plans, those are speculations without any promises

This isn’t quite accurate. There are many precedents that demonstrate it can be done — languages like C++, Python, JavaScript, Rust, and Swift all have centralized, clearly communicated plans and roadmaps. These communities manage to articulate an overarching direction effectively. I don’t understand how “it’s hard to do” can serve as a justification when so many successful examples exist showing that it can be done efficiently.

A fair number of pull requests still seem to be coming from “3rd parties”, so it seems hard to read all of their minds.

That’s again true for nearly every open-source language. Python’s PEP process exist precisely to address this challenge — providing a standardized way to propose ideas, discuss them openly, and communicate the broader direction of the language. Not depend on some local groups that may or may not do something without any clear vision.

To reiterate, my original point was simply this:

It’s difficult to stay informed about Julia’s long-term direction when the relevant information is scattered across issues, pull requests, and videos. Other language communities consolidate this information in one accessible place. I’m not looking for advice to “just search harder” — of course I already do that. The problem is that this approach is inherently inefficient for both users and contributors. Without a centralized roadmap or vision, it feels like there’s no cohesive direction — just independent groups working in isolation on what interests them (or perhaps not working at all — who can tell?).

3 Likes
19

…funding for language development itself

It would be very nice if Julia was in this situation, but it isn’t.

6 Likes
20

This is good, more should be made of Juleps IMO.

I am deeply sympathetic to this. There is value in having more organisation than Julia currently has.

4 Likes