HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
JuliaLang
julia
Julia2012–2026
JuliaLang / julia

julia

The Julia Programming Language

178Distinct people
335Mentions
5Explicit recommenders
49.3KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

The Julia Programming Language

GitHub

Where it is used

  • Aladdin — Aladdin uses Julia to power its analytics platform. BlackRock deploys Julia within the Aladdin system to run its analytics. Source

What people are saying

There's another approach for doing this: generate a random number between 1 and 2 (they all have the same exponent) and then subtract 1 (that's the default implementation in…

FabHK used a recommendation phrase. 5 indexed comments match. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 11:39:46 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year335 dated mentions

Observed mentions: 2012-02-18 12:55:37 UTC to 2026-10-12 16:48:37 UTC.

0102030402012-01-01 00:00:00 UTC to 2013-01-01 00:00:00 UTC (exclusive): 12 mentions; 1 submissions, 11 comments20122013-01-01 00:00:00 UTC to 2014-01-01 00:00:00 UTC (exclusive): 13 mentions; 1 submissions, 12 comments2014-01-01 00:00:00 UTC to 2015-01-01 00:00:00 UTC (exclusive): 42 mentions; 7 submissions, 35 comments2015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 26 mentions; 4 submissions, 22 comments2016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 26 mentions; 4 submissions, 22 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 19 mentions; 5 submissions, 14 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 29 mentions; 5 submissions, 24 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 31 mentions; 4 submissions, 27 comments20192020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 22 mentions; 3 submissions, 19 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 37 mentions; 2 submissions, 35 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 38 mentions; 1 submissions, 37 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 22 mentions; 4 submissions, 18 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 8 mentions; 0 submissions, 8 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 6 mentions; 0 submissions, 6 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 4 mentions; 1 submissions, 3 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20122012-01-01 00:00:00 UTC2013-01-01 00:00:00 UTC12111
20132013-01-01 00:00:00 UTC2014-01-01 00:00:00 UTC13112
20142014-01-01 00:00:00 UTC2015-01-01 00:00:00 UTC42735
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC26422
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC26422
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC19514
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC29524
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC31427
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC22319
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC37235
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC38137
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC22418
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC808
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC606
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC413

From the project README

An excerpt from the repository, fetched Nov 12, 2026.

Read the project’s introduction
Documentation Continuous integration Code coverage The Julia Language Julia is a high-level, high-performance dynamic language for technical computing. The main homepage for Julia can be found at julialang.org. This is the GitHub repository of Julia source code, including instructions for compiling and installing Julia, below. Resources Homepage: https://julialang.org Install: https://julialang.org/downloads/ Source code: https://github.com/JuliaLang/julia Documentation: https://docs.julialang.org Packages: https://julialang.org/packages/ Discussion forum: https://discourse.julialang.org Zulip: https://julialang.zulipchat.com/ Slack: https://julialang.slack.com (get an invite from https://julialang.org/slack/) YouTube: https://www.youtube.com/user/JuliaLanguage Code coverage: https://coveralls.io/r/JuliaLang/julia Contributing to Julia We welcome contributions from developers of all experience levels, including bug fixes, documentation improvements, tests, and performance enhancements. New contributors are encouraged to start by reading CONTRIBUTING.md. ImportantIf your pull request contains substantive contributions from a generative AI tool, please disclose so with details, and review all changes before opening. This also applies to other content, such as issues, discussions, and comments. Learning Julia Learning resources Binary Installation The recommended way of installing Julia is to use juliaup which will install the latest stable julia for you and help keep it up to date. It can also let you install and run different Julia versions simultaneously. Instructions for this can be found here. If you want to manually download specific Julia binaries, you can find those on the Manual Downloads page. The downloads page also provides details on the different tiers of support for OS and platform combinations. If everything works correctly, you will get a julia program and when you run it in a terminal or command prompt, you will see a Julia banner and an interactive prompt into which you can enter expressions for evaluation. You can read about getting started in the manual. Note: Although some OS package managers provide Julia, such installations are neither maintained nor endorsed by the Julia project. They may be outdated, broken and/or unmaintained. We recommend you use the official Julia binaries instead. Building Julia First, make sure you have all the required dependencies installed. Then, acquire the source code by cloning the git repository: git clone https://github.com/JuliaLang/julia.git and then use the command prompt to change into the resulting julia directory. By default, you will be building the latest unstable version of Julia. However, most users should use the most recent stable version of Julia. You can get this version by running: (replace [tag] with the desired tag) git checkout [tag] To build the julia executable, run make from within the julia directory. Building Julia requires 2GiB of disk space and approximately 4GiB of virtual memory. Note: The build process will fail badly if any of the build directory's parent directories have spaces or other shell meta-characters such as $ or : in their names (this is due to a limitation in GNU make). Once it is built, you can run the julia executable. From within the julia directory, run ./julia Your first test of Julia determines whether your build is working properly. From the julia directory, type make testall. You should see output that lists a series of running tests; if they complete without error, you should be in good shape to start using Julia. You can read about getting started in the manual. Detailed build instructions, should they be necessary, are included in the build documentation. Uninstalling Julia By default, Julia does not install anything outside the directory it was cloned into and ~/.julia. Julia and the vast majority of Julia packages can be completely uninstalled by deleting these two directories. Source Code Organization The Julia source code is organized as follows: Directory Contents base/ source code for the Base module (part of Julia's standard library) cli/ source for the command line interface/REPL contrib/ miscellaneous scripts deps/ external dependencies doc/src/ source for the user manual etc/ contains startup.jl src/ source for Julia language core stdlib/ source code for other standard library packages test/ test suites Terminal, Editors and IDEs The Julia REPL is quite powerful. See the section in the manual on the Julia REPL for more details. On Windows, we highly recommend running Julia in a modern terminal, such as Windows Terminal from the Microsoft Store. Support for editing Julia is available for many widely used editors: Emacs, Vim, Sublime Text, and many others. For users who prefer IDEs, we recommend using VS Code with the julia-vscode plugin. For notebook users, Jupyter notebook support is available through the IJulia package, and the Pluto.jl package provides Pluto notebooks.
Read the full README on GitHub

What Hacker News says

38 sources
There are some nice tools for 3D PDEs which connect to DiffEq like GridAP (https://docs.sciml.ai/Gridap/stable/) and Ferrite (https://docs.sciml.ai/Ferrite/stable/). PDE tooling is where focus has been moving to as things evolve. As for JIT, just today there was a PR that was merged that makes Julia cache and reuse binaries of packages (https://github.com/JuliaLang/julia/pull/47184). It won't be out until the next release of Julia, but it's a pretty major improvement to not JIT fully inferred package calls.
In Extending Python with Rust
We bring up these posts every time Julia is mentioned on HN. I've become reticent to respond to these comments. It seems like any response that does not sound like it came from a customer service representative, e.g. "Thank you for expressing your concerns. We acknowledge there are issues, and we are working on it.", will get interpreted as being dismissive or arrogant. I frankly prefer to hear technical responses to the critiques and about how specific issues are being addressed even if they may not be to my satisfaction. Still though, it is important to continue a conversation about this. We should encourage a dialog rather than suppress it. What's clear to me is that the current state of Julia is not for everyone, and that's fine. There are many other solutions in this space with extensive funding or experience that are likely a better
Read the rest
fit for many. For some, incremental improvements on existing technology are more appropriate than a new language introducing new paradigms. Working with Julia is a participatory process, and I understand not everyone has time for that. I thank the pioneers for trying, even if they have decided its not for them at this stage. At the same time, some circumstances require more than incremental change. On one hand, the comments here posit that nothing is changing and that Julia is slow. Perhaps more precisely the complaint is about its compilation latency: 1. "It has been a constant complaint and a constant broken promise." 2. "every couple of years I try julia again, and every time it's still slow" On the other hand, these comments are replying to a post about a pull request [1] addressing "time to first X" (TTFX) by providing infrastructure to cache native code on a per package basis. For further background, please refer to a prior pull request merged last month which tackles the prerequisite step of supporting external linkage in system images [2]. The recent pull request also contains an evaluation from a "non-core" developer who is reviewing the pull request, sharing his real world experience with graphs, measurements, and comments about the documentation. To me this pull request is exemplary of how Julia development should work and how users can contribute to the process. Referring to the original article, I also notice that many of the companies and startups mentioned are involved with the development of the Julia language itself rather than merely the application of the language. Perhaps this ability to participate in Julia development at this stage is seen as a feature to these organizations. I'm unclear what the critique is here with rehasing these comments in response to a pull request. Should that pull request take another approach? Is code review on that pull request progressing too slowly? Is it that the priority should shift away from the compiler to provide further infrastructure for correctness, traits, or some other feature? There's a lost opportunity here to actually expand the conversation rather than reiterating the same arguments. Nonetheless, I thank thetwentyone for posting news about a substantive pull request addressing compilation based latency. I hope to hear more about these ongoing efforts. [1] https://github.com/JuliaLang/julia/pull/47184 [2] https://github.com/JuliaLang/julia/pull/44527
In Startups are building with the Julia Programming Language
> Julia's threading macro is surprisingly brittle, only letting you chain single-argument functions Julia's threading/piping is surprisingly limited, but the phrasing here (combined with the link) could make things confusing to a Julia beginner. So to make things clear: * The linked page is talking about an external Julia package which provides a macro. And that macro lets you use the `_` syntax similar to what you describe Racket as having. * Julia's default inbuilt piping syntax is the one with the single-argument limitation, and that's an operator, not a macro. There's been a lot of discussion about bringing the `_` syntax or something like it to the base language, but there seem to be implementation difficulties. [1] > +R :: https://r4ds.had.co.nz/pipes.html This page is talking about magrittr piping (which is probably still the most
Read the rest
popular), but base R also got inbuilt piping syntax with version 4.1. It automatically passes the piped-in value as the first argument to the subsequent function. [2] [3] [1] https://github.com/JuliaLang/julia/pull/24990 [2] https://www.r-bloggers.com/2021/05/the-new-r-pipe/ [3] https://michaelbarrowman.co.uk/post/the-new-base-pipe/
In Elixir-style pipelines in Ruby
The error messages you mentioned in here have been completely overhauled. In fact, most things in SciML are now caught and throw very high level error messages. We also revamped the whole documentation and added docstrings everywhere. See https://sciml.ai/news/2022/10/08/error_messages/ . We're also in the middle of rolling out a new documentation (https://docs.sciml.ai/Overview/stable/) that has a lot more of a split between tutorials and references. It's not complete, but the core push of this should be completed in about 2 weeks. As for loading times, we've transformed those as documented in https://sciml.ai/news/2022/09/21/compile_time/ (taking a core case from 30 seconds to 0.1 seconds), and Julia v1.9 is releasing a feature where package precompilation can store LLVM-compiled binaries. So I think most of the blog post has already be
Read the rest
en addressed? The one thing we haven't done is improved type printing. I am with you on that one, and actually opened a Base Julia issue about it way before your blog post: https://github.com/JuliaLang/julia/issues/36517 . It requires a Base Julia fix though, so that's a bit out of my hands. Also, I think it would be good for Base Julia to do a bit of the error message interpreting that SciML has done, specifically for broadcast (https://github.com/JuliaLang/julia/issues/45086). So there are some more improvements to be done, but I don't think the blog post is up-to-date given the overhauls that were done in the summer of 2022 (thanks to your feedback). It would be nice to hear updated thoughts when you have a chance to try all of these improvements (especially when v1.9 comes out with the cached binaries)!
In What's Great about Julia?
> My mistake in retrospect was using small arrays as part of a struct, which being immutable got replaced at each time step with a new struct requiring new arrays to be allocated and initialized. I would not have done that in c++, but julia puts my brain in matlab mode. I see. Yes, it's an interesting design space where Julia makes both heap and stack allocations easy enough, so sometimes you just reach for the heap like in MATLAB mode. Hopefully Prem and Shuhei's work lands soon enough to stack allocate small non-escaping arrays so that user's done need to think about this. > Alignment I'd assumed, but padding the struct instead of the tuple did nothing, so probably extra work to clear a piece of an simd load. Any insight on why avx availability didn't help would be appreciated. I did verify some avx instructions were in the asm it gener
Read the rest
ated, so it knew, it just didn't use. The major differences at this point seem to come down to GCC (g++) vs LLVM and proofs of aliasing. LLVM's auto-vectorizer isn't that great, and it seems to be able to prove 2 arrays are not aliasing less reliably. For the first part, some people have just improved the loop analysis code from the Julia side (https://github.com/JuliaSIMD/LoopVectorization.jl), forcing SIMD onto LLVM can help it make the right choices. But for the second part you do need to do `@simd ivdep for ...` (or use LoopVectorization.jl) to match some C++ examples. This is hopefully one of the things that the JET.jl and other new analysis passes can help with, along with the new effects system (see https://github.com/JuliaLang/julia/pull/43852, this is a pretty huge new compiler feature in v1.8, but right now it's manually specified and will take time before things like https://github.com/JuliaLang/julia/pull/44822 land and start to make it more pervasive). When that's all together, LLVM will have more ammo for proving things more effectively (pun intended).
In Python 3.11 vs 3.10 performance
They aren't, which is why the statement doesn't make sense haha. The difference is really just that tuples of isbits types can be stack allocated (and tuples of isbits types are isbits, so they can nest, etc.), and so in some cases with sufficiently small amounts of data, creating stack allocated objects is much faster than creating heap allocated objects. But if you compare concretely typed heap allocated arrays in Julia and C, there's no real performance difference (Steven Johnson has a nice notebook displaying this https://scpo-compecon.github.io/CoursePack/Html/languages-be..., and if you see the work on LoopVectorization.jl it makes it really clear that the only major difference is that C++ tends to know how to prove non-aliasing (ivdep) in a bit more places (right now)). So the real question is, did you actually want to use a heap a
Read the rest
llocated object? I think this really catches people new to performance optimization off guard since in other dynamic languages you don't have such control to "know" things will be placed on the stack, so you generally heap allocate everything (Python even heap allocates numbers), which is one of the main reasons for the performance difference against C. Julia gives you the tools to write code that doesn't heap allocate objects, but also makes it easy to heap allocate objects (because if you had to `malloc` and `free` everywhere... well you'd definitely lose the "like Python" and and be much closer to C++ or Rust in terms of "ease of use", which would defeat the purpose for many cases). But if you come from a higher level language, there's this magical bizarre land of "things that don't allocate" (on the heap) and so you learn "oh I got 30x faster from Python, but then someone on a forum showed me how to do 100x better by not making arrays?", which is somewhat obvious from a C++ mindset but less obvious from a higher level language mindset. And FWIW, this is probably the biggest performance issue newcomers run into, and I think one of the things to which a solution is required to make it mainstream. Thankfully, there's already prototype PRs that are well underway, for example https://github.com/JuliaLang/julia/pull/43573 automatically stack-allocates small arrays which can prove certain escape properties, https://github.com/JuliaLang/julia/pull/43777 is looking to hoist allocations out of loops so even if they are required they are minimized in the loop contexts automatically, etc. The biggest impediment is that EscapeAnalysis.jl is not in Base, and it requires JET.jl which is not in Base, and so both of those need to be made "Base friendly" to join the standard library and then the compiler can start to rely on its analysis (which will be nice because JET.jl can do things like throw more statically-deducible compile time errors, another thing people ask for with Julia). There's a few people who are working really hard on doing this, so it is a current issue but it's a known one with prototyped solutions and a direction to get it into the shipped compiler. When that's all said and done, of course "good programming" will still help the compiler in some cases, but in most people shouldn't have to worry about stack vs heap (it's purposefully not part of the user API in Julia and considered a compiler detail for exactly this reason, so it's non-breaking for the compiler to change where objects live and improve performance over time).
In Python 3.11 vs 3.10 performance
The issue is not that the bugs are with correctness of multiple dispatch, but that multiple dispatch allows you to combine generic programming with abstract data types. Thus, one can have a generic implementation in base Julia, and someone can pass a new user data type - a combination that can easily not work. Some of the frustration also arises from types such as OffsetArrays that are included in the base distribution, but not as well supported and tested as the regular Arrays type. Thus, the discussion here tends to focus on defining interfaces, and of course on better testing of uncommonly used data types. In general, we've not had a formal roadmap - but we present a "State of Julia" talk at JuliaCon every year. But very broadly, the list (of the top of my head) includes: improving a lot of the underlying compiler infrastructure overal
Read the rest
l, improving support differentiable programming, improving garbage collection, support for GPUs from multiple vendors (too many of those now), supporting apple silicon, type system support for tools like JET.jl. NEWS.md is generally updated during the course of a release cycle, which eventually becomes release notes, and then post release, we put together a highlights blog post. https://github.com/JuliaLang/julia/blob/master/NEWS.md
In Why I still recommend Julia
> Yuri's criticism was not that Julia has correctness bugs as a language Are you sure? Here are some issues from the post: "Wrong if-else control flow" seems like a language issue? bug is still open [0] "Wrong results since some copyto! methods don’t check for aliasing" seems like a bug in a core library. The bug, which is filed against Julia, not some third-party library, is still open [1] "The product function can produce incorrect results for 8-bit, 16-bit, and 32-bit integers" was a bug in a core library, which was fixed [2] "Base functions sum!, prod!, any!, and all! may silently return incorrect results" seems like a bug in a core library and is still open [3] "Off-by-one error in dayofquarter() in leap years" seems like a bug in a core library which was fixed [4] "Pipeline with stdout=IOStream writes out of order" seems like a bug
Read the rest
in a core library and is still open [5] I've been deliberately conservative here and only posted the issues from Yuri's post that are in the JuliaLang/julia repository. The other issues are filed against JuliaStats/Distributions.jl, JuliaStats/StatsBase.jl, JuliaCollections/OrderedCollections.jl, and JuliaPhysics/Measurements.jl. Since I have not used Julia very much, I don't know whether these are commonly used libraries or obscure libraries nobody uses, but they seem pretty close to the core use-cases of the language. Maybe someone who uses the language a lot more can shed some light on this issue. Some commenters seem exhausted by what they perceive as a continual stream of lies about these topics, which has left them less inclined to post about them. [0]: https://github.com/JuliaLang/julia/issues/41096 [1]: https://github.com/JuliaLang/julia/issues/39460 [2]: https://github.com/JuliaLang/julia/issues/39183 [3]: https://github.com/JuliaLang/julia/issues/39385 [4]: https://github.com/JuliaLang/julia/pull/36543 [5]: https://github.com/JuliaLang/julia/issues/36069
In Why I still recommend Julia

Showing the 15 most recent of 38 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.