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, 4:59:52 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

29 sources
Looking at the Rust source [1] it seems there the `next()` call has some overhead, so it's probably not the compiler. I remember this was simple to implement in Julia [2] where you can iterate over the full range `for i = typemin(Int):typemax(Int) ... end` without overflow and without overhead. Same should be possible in Rust I think. [1] https://doc.rust-lang.org/src/core/iter/range.rs.html#340-35... [2] https://github.com/JuliaLang/julia/blob/master/base/range.jl...
In Comparing Pythagorean triples in C++, D, and Rust
>I’m curious if anyone has a page with updated benchmarks for various sizes of FFTs on modern CPUs and maybe GPUs, testing whatever FFT libraries out there are still being actively maintained (including those which limit themselves to power-of-2 sizes) This is the most updated that I know of online (2014) https://github.com/JuliaLang/julia/pull/6193#issuecomment-61... If the array is large enough for a GPU, then yes a GPU version would rip it to shreds (not shown, but known). You can see the MKL advantage in there, but FFTW still performs pretty admirably. Everyone pretty much uses MKL or FFTW these days. I don't think there's as much development in this space because these are all pretty well-optimized now. Multi-process parallel for these is supposedly not difficult and can use a very similar strategy, but GPU really requires some diffe
Read the rest
rent approaches and that's where the development is these days. Also, a lot of mathematicians have had a more recent focus on advancing the realm of spectral discretizations beyond FFTs, for example see Chebfun and ApproxFun, and things like FastTransforms.jl where the interesting this is non-uniformly spaced FFTs and similar transforms.
In Why is FFTW written in OCaml and what makes it so fast?
>FWIW, proper hygienic macros and scientific focused array types makes this sort of meta-programming optimization in Julia kinda fun. And FWIW the author of FFTW is a big Julia contributor / package author nowadays. A long time ago (2014) he did write a Julia-based version of FFTW: https://github.com/JuliaLang/julia/pull/6193#issuecomment-61... This was back before Julia could do auto-SIMD optimizations, and it got quite close to FFTW without SIMD. He mentioned somewhere that modern Julia should be able to get very close to FFTW with SIMD, given that Julia now has better inlining heuristics, interprocedural optimizations, automatic SIMD, etc. (2014 was the stone age for Julia). If you read the rest of the thread, most of the discussion was about a standard library system so FFTW could be moved out. With Julia v1.0 FFTW is now in the stand
Read the rest
ard library, which gives room for a pure Julia FFT to be standard. So this should get revived soon and we will have a beautiful generic FFTW algorithm. I can't wait :)
In Why is FFTW written in OCaml and what makes it so fast?
Julia works great on clusters, I use it all the time. It's learning a lot from Chapel too. Chapel has an amazing parallelism model, and a lot of Julia's parallelism is learning from it, including the near future hierarchical task-based multithreading. Julia was designed for interactive usage that can generate fast code, while Chapel was designed for the more traditional HPC usage. With more and more people using interactive languages on the HPC to avoid the translation step of the two-language problem though, Julia seems to be eating into the domain where more hardcore people used to write C++ and Fortran with MPI (I was one of those for a bit!). But while "no need to rewrite code, just take your interactive script and throw it on the cluster" is right for some, other applications will want a statically compiled language with a strong par
Read the rest
allelism model which is Chapel. The issue I see with Chapel though is that HPC is such a small community compared to larger scientific computing, and Julia has such a good design that it is very easy to improve (using Julia code!) with a large developer group (currently 736 contributors, that is quite a bit more than CPython has ever had and Julia is a lot younger), Julia is a lot more nimble. So when Chapel gets a good idea, sure enough there's an MIT programming languages or HPC fellow who proposes it in Julia, and so you get stuff like https://github.com/JuliaLang/julia/pull/22631 soon after. That doesn't mean Chapel is bad, but Julia already has the largest contributor base of any of the open source scientific computing languages still being developed, and that manpower is definitely useful for keeping up with the current research trends (working on Julia is a good way to get a math/CS PhD at MIT :) )
In What Is Systems Programming, Really?
I work professionally as an applied mathematician and I've struggled to understand where Julia fits into the tools already available. In terms of prototyping algorithms, MATLAB/Octave still seems to be the best choice. We have access to an enormous number of builtin routines that help diagnose what's going on when an algorithm breaks. That's not to say other language don't, but the ability to set a single dbstop command and then run some kind of diagnostic like plotting the distribution of eigenvalues with d=eig(A); plot(real(d),imag(d),'x') is amazing and saves time. There's also a very straightforward workflow to run the debugger and then drop into gdb in case the case we need to interact with external libraries. Now, certainly, MATLAB/Octave is weak, in my opinion, for generating larger software projects that need to interact with t
Read the rest
he rest of the world. This includes things like network connections, GUIs, database access, etc. Alternatively, sometimes a new low level driver needs to be written, which needs to be very fast. All that same, that ecosystem seems to be much better in languages like C++ and Python. Though, I've been experimenting with Rust as an alternative to C++ for this use case. At this point, if I have trouble with the algorithms, I can run it in parallel with the MATLAB/Octave to diagnose how things differ. Coming back to Julia, where is it supposed to fit in? To me, there's a better prototyping language, production language, and bare metal fast language. I will make one last quip and that's the licensing. Frankly, the big advantage of MATLAB is that it provides license cover. Mathworks has obtained the appropriate licenses for your expensive factorizations and sparse matrix methodology. Julia has not and they remain largely under GPL: https://github.com/JuliaLang/julia/blob/master/LICENSE.md Look at things like SUITESPARSE. Practically, what that means is that I can deliver MATLAB code to my clients and I don't have to disclose the source externally due to GPL requirements. Now, maybe they choose to run Octave. That's fine and then they can assume the responsibility for GPL code. However, for me, I maintain a MATLAB license and that gives me coverage for a whole host of other licenses in the context of MATLAB code and that makes my life vastly easier than if I were to develop and deliver code in another language.
In Try OCaml
Just to clarify: * Julia has had tasks/co-routines basically forever and uses them for all blocking operations so that no explicit non-blocking I/O or callbacks are required. * It also supports multithreading using the @threads macro. * However, it does not yet map tasks to threads, but that is very close to ready: https://github.com/JuliaLang/julia/pull/22631. We expect this work to be finished in a near-future 1.x release and then Julia will support M:N multiplexing.
In Julia 1.0
Well, I have indeed spent more time thinking about this than is probably healthy, but here are some nice edge cases to think about: - https://github.com/JuliaLang/julia/issues/14826 mod(-eps(), 4.0) - https://github.com/JuliaLang/julia/issues/17415 fld(1.0,0.2) - https://github.com/JuliaLang/julia/issues/3127 mod(1.0,0.1) - https://github.com/JuliaLang/julia/issues/3104 mod(0.95,0.01) I'm pretty sure there are more issues. re: mod 2pi, typically it is most accurate to reduce to (-pi,pi) (i.e. division rounding to nearest). Also to get it accurate you need fancy range reduction algorithms, hence julia has rem2pi https://docs.julialang.org/en/stable/base/math/#Base.Math.re...
In Julia 1.0

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