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:20:21 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

37 sources
You probably could get perturbation confusion in reverse mode, but it's not an easy trap like it is with forward mode. The problem with forward mode AD is that it's deceptively easy: you transform every number a into a pair of numbers (a,b) and you change every function from f(a) to (f(a),f'(a)), put the chain rule on it, and you're done. Whether you call it dual number arithmetic or a compiler transformation it's the same thing in the end. The issue with perturbation confusion is that you've created this "secret extra number" to store the derivative data, and so if two things are differentiating code at the same time, you need to make sure you turn (a,b) into (a,a',b,b') and that all layers of AD are always grabbing the right value out of there. Note that in the way I wrote it, if you assumed "the b term is always num[2] in the tuple", o
Read the rest
ops perturbation confusion, and so your generated code needs to be "smart" (but not lose efficiency!). Thus the fixes are proofs and tagging systems that ensure the right perturbation terms are always used in the right places. With reverse mode AD, this is much less likely to be an issue because the AD system isn't necessarily storing and working on hidden extensions to the values, it's running a function forwards and then running a separate function backwards having remembered some values from the forward pass. If the remembered values are correct and never modified, then generating a higher order derivative is just as safe as the first. But that last little detail is thus what I think is most akin to perturbation confusion in reverse mode: reverse mode has the assumption that the objects captured in the forward pass will not be changed (or will be at least be back in the correct state) when it is trying to reverse. The easy way to break this assumption doesn't even require second derivatives. The easiest way to break it is mutation: if you walk forward by doing Ax, then the reverse pass wants to do A'v so it just keeps the pointer to A, but if A gets mutated in the meantime then using that pointer is incorrect. This is the reason why most AD systems simply disallow mutation except in very special unoptimized cases (PyTorch, Jax, Zygote, ...). Enzyme.jl is an exception because it takes a global analysis of the program it's differentiating (with proper escape analysis etc. passes at the LLVM level) in order to know that any mutation going forward will be reversed during the reverse path, so by the time it gets back to A'*v it knows A will be the same. Higher level ADs could go cowboy YOLO style and just assume the reversed matrix is correct (and it might be a lot of the time), though that causes some pretty major concerns for correctness. The other option is to simply make a full copy of A every time you mutate an element, so have fun if you loop through your weight matrix. The Diffractor.jl near future approach is more like Haskell GHC where it just wants you to give it the non-mutating code so it can try and generate the mutating code when that would be more efficient (https://github.com/JuliaLang/julia/pull/42465). So with forward-mode AD there was an entire literature around schemes of provable safety to perturbation confusion, and I'm surprised we haven't already started seeing papers about provable safety with respect to mutation in higher-level reverse-mode AD. I would suspect that the only reason why it hasn't started is that the people who write type-theoretic proofs tend to be the functional programming pure function folks that tell people to never mutate anyways, so the literature might instead go the direction of escape analysis proofs to optimize immutable array code to (and beyond) the performance of mutation code on commonly mutating applications. Either way it's getting there with the same purpose in mind.
In Trade-Offs in Automatic Differentiation: TensorFlow, PyTorch, Jax, and Julia
If the purpose of the AD was to do something simply for standard ML workflows, the current AD tools are not the right design for that. They are too complex and solve a harder problem than they would need to. A better approach would be to use the abstract interpretation afforded by Symbolics.jl, mixed with the array symbolics, and use MetaTheory.jl to define simplification rules similar to XLA. You'd essentially get a slightly expanded Jax/TensorFlow with graph simplification rules that could be adjusted/improved directly from the host language. There's a prototype (ReversePropogation.jl), but it needs array support to actually be useful for this application. Or if you don't need the whole stack to be modifiable from Julia, a better interpreter on XLA.jl would get you there. A sufficiently decent lone coder could get those up and optimized
Read the rest
fairly quickly for standard ML applications, if that's the goal. Diffractor.jl has a much loftier goal: optimized differentiable programming of any code from any package in the Julia ecosystem. Because it's building typed IR, it will need a full set of Julia-based analysis tools (escape analysis, loop-invariant code motion, etc.) to approach the amount of optimization XLA can do when XLA optimizations are applicable. While such passes are being developed (for example, this is the PR for putting immutable array optimizations into the language so that Diffractor-friendly immutable can generate the optimized mutable form: https://github.com/JuliaLang/julia/pull/42465), it's at least a few years away before it's doing something like reliably combining multiple matrix-vector products into a matrix-matrix BLAS3 call. That would put it on even footing today to compete against PyTorch in a kernel vs kernel optimization battle, but not against TensorFlow code in cases where XLA optimizations are doing something more. "Just wait 3 years and it will be really cool" is not a good way to start building a robust community, instead those interested in it need to ask how to demonstrate the improvements afforded by the added generality today. That's why what's making the project tick right now is the ARPA-E projects for physics-informed neural networks, the DJ4Earth project to do direct differentiation of the CLIMA climate model without changing any of the model code (https://dj4earth.github.io/), etc. Those kinds of projects are what is keeping a lot of the dev team open to be full time on these AD and compiler optimization projects. But if successful, it will also give an AD that is great for standard ML.
In Trade-Offs in Automatic Differentiation: TensorFlow, PyTorch, Jax, and Julia
Mutation is tricky, because basically the only way to do it sanely is to copy all data into the residual, but since most arrays aren't actually mutated, that's extremely wasteful. I've been hoping to address this by changing mutability in the language more generally (e.g. https://github.com/JuliaLang/julia/pull/42465) to make immutable arrays the default at which point there wouldn't be a penalty anymore. I've had request to do the mutable copying optionally, but it's a bit tricky, because it needs rule system integration and the rule system currently doesn't reason about mutation. As for exceptions and recursion, shouldn't be a problem, just needs to be implemented.
In Julia 1.7 Highlights
It's acknowledged. The full redefinition of any function in any context was solved by RuntimeGeneratedFunctions and we use it extensively throughout SciML, ModelingToolkit, Pumas, etc. so it's fair to say struct redefinitions are the only thing left. That said, "struct redefinitions" are done all of the time in many contexts: if you know you may need to do this, you can just use a named tuple which acts just like an anonymous type and obeys dispatch on a named form that you can then hijack at runtime. With smart engineering then you can be redefining everything on the fly, and we do this through MTK quite regularly. That said, it would be nice to do the last feat of full redefinition of non-anonymous structs, and the latest proposal for how to do struct redefinition is https://github.com/JuliaLang/julia/issues/40399. So we both built and
Read the rest
provided solutions for how to do it, showed how to do it in libraries, tutorials, videos, etc. How is that not acknowledging the point of view and doing something about it? You might want to try and acknowledge the other point of view where I note that, hey, we did make this work but it was a smaller deal then we thought because we legally cannot employ it in many production contexts. We're still going to work out a few details for fun and ease of debugging, but given that we have extensively looked into and thought deeply about the whole issue, we have noticed that the last little bits are less useful than we had thought (at least in the contexts and applications I have been discussing, like clinical trial analysis). That doesn't mean we won't finish the last pieces, but given how much of it you can already do and how many teaching materials show how to do work around the issues in any real-world context, and how little of a real-world application the last few bits have, it shouldn't be surprising that the last pieces haven't been a huge priority. So instead of looking narrowly at one factor, I encourage you to take a more global view.
In PyTorch: Where we are headed and why it looks a lot like Julia (but not exactly)
I would say the almost every version of Julia 1.x has better in terms of code startup. as in 1.7 > 1.6 > 1.5 > 1.4 > 1.3 > etc... it's especially goten way better since julia 1.5, so really mostly in the last few years. In julia 1.8, what's interesting to me is that the julia runtime will be separated from the llvm codegen; https://github.com/JuliaLang/julia/pull/41936 the immediate effect is to allow small static binaries without a huge runtime (namely the LLVM ORC), but the side effect is probably that the interpreter will also get better in cases where you don't want JIT.
In PyTorch: Where we are headed and why it looks a lot like Julia (but not exactly)
there was dylan before julia, so julia might just be reinventing dylan :) but that's not what's interesting the julia project is in fact very interesting to me and has a great team developing its ecosystem and i work with it alongside python for numerical work. however one key drawback (compared to common lisp) for me is that it is not self-compiled. it is hosted on llvm and over 30% of its repository is in another language (mainly C and C++)[0]. but i am saying this only in comparison to common lisp. other languages are not different to this, and are much worse. as far as scientific computing is concerned, i would work with julia over python any day [0] https://github.com/JuliaLang/julia
In Why Lisp? (2015)
> (; x, y) = newS > Now x has the value 4 and y has the value 5. I believe this is supposed to be a and b here (matching the names of the fields of the struct). That's what the NEWS.md [1] implies, and that's what intuitively makes sense given the ; syntax. > Install package? │ (@v1.7) pkg> add Example └ (y/n) [y]: Surprised it defaults to [y] option, especially since packages can be pretty heavy with artifacts and lots of dependencies to precompile. One accidental extra Return and you might be sitting there for five minutes. > keepat!(v, i) Not a fan of the name. The ! indicates the mutation as the article points out, but keeponlyat! would have been much clearer and immediately obvious, enough to more than justify its length IMO. Lots of nice quality of life improvements in this version. One that the article doesn't mentio
Read the rest
n is `julia --project=@myenv` [1] - being able to specify a shared environment as the starting environment for the REPL. [1] https://github.com/JuliaLang/julia/blob/v1.7.0-rc1/NEWS.md
In New features coming in Julia 1.7

Showing the 15 most recent of 37 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.