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, 12:01:57 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

13 sources
While it's great having fast kernels, there is a huge amount of computing that can't be crammed into a matrix multiply or any other high-performance kernel. If your assertion were even remotely true, there wouldn't be so many Python, Matlab and R extensions written in C, and things like Cython [1] and Numba [2] wouldn't exist. Sometimes you just want to write a for loop or use recursion and not have it be dog slow. Being "allowed" to use iteration and recursion without a performance penalty is one of the things that Julia provides. As to not being able to beat MKL, it isn't even necessarily hands down the best BLAS around. For example, OpenBLAS [3] is about as good as MKL, depending on what you're doing. They each have their strengths and weaknesses: 1. OpenBLAS is faster than MKL in all the level-1 tests for small numbers of threads (1-4
Read the rest
). The difference is larger for smaller problems. In small level-2 and level-3 instances, however, MKL does better. Specifically in the case of matrix-vector products, MKL seems to do much better. 2. On various linear algebra tests with LAPACK, MKL is faster for smaller problem sizes, whereas OpenBLAS is faster for larger problems. 3. In general, MKL seems to have better tuning for threads. OpenBLAS, on the other hand, has optimized kernels for LU and Cholesky factorizations, which is what GotoBLAS [4] – on which OpenBLAS is based – did too. Blake Johnson, who is a regular Julia contributor, did an excellent analysis of this, complete with pretty Gadfly-generated graphs, which can be found in the discussion of this issue: https://github.com/JuliaLang/julia/issues/3965. Interestingly, I believe that Kazushige Goto, who originally created GotoBLAS, now works on MKL at Intel. [1] http://cython.org [2] http://numba.pydata.org [3] https://github.com/xianyi/OpenBLAS [4] http://en.wikipedia.org/wiki/GotoBLAS
In Why I’m not on the Julia bandwagon (yet) (2012)
For what it's worth, Julia supports setting rounding modes in a way that works across both native floating-point types (Float32 and Float64) and BigFloats: http://docs.julialang.org/en/latest/stdlib/base/#Base.get_ro... This stuff is incredibly important for numerical work and it's really a shame that mainstream languages have effectively rejected this key piece of functionality – that the hardware supports. There's an open GitHub umbrella issue tracking support for all of the pieces of functionality that Kahan advocates: https://github.com/JuliaLang/julia/issues/2976 I'm not sure about signaling NaNs though. There have been rumblings that future hardware might not support them.
In An Interview with the Old Man of Floating-Point (1998)
Thanks for checking Julia out. I fear there is a fair amount of misinformation in your comment, however, so it seems that a few things were lost in your reading of Julia's code (some of which is admittedly quite tricky). I hope you don't mind if I address some of it. The first point is that Julia already has excellent performance on a par with most compiled languages, including, e.g. Haskell, whether they are using LLVM or not. Straight-forward Julia code is typically within a factor of two of C. That's shown in the microbenchmarks on Julia's web site [http://julialang.org/], but, of course, that's not entirely convincing because, you know, they're microbenchmarks and we wrote them. However, similar performance is consistently found in real-world applications by other people. You don't have to take my word for it – here's what Tim Holy [h
Read the rest
ttp://holylab.wustl.edu] has to say: https://groups.google.com/d/msg/julia-users/eQTYBxTnVEs/LDAv.... Iain Dunning and Miles Lubin also found it to be well within a factor of 2 of highly optimized C++ code when implementing realistic linear programming codes in pure Julia: https://github.com/JuliaLang/julia-tutorial/blob/master/Nume.... The benchmarks appear on page 7 of their presentation. This statement about Julia's high-level optimizations is entirely wrong: > i've looked at how it compiles to llvm, and it basically punts any optimization to the llvm side, aside from the most basic tracing jit method monomorphization/specialization. Julia does no tracing at all, so it's definitely not a tracing JIT. A relatively small (but growing) very crucial amount of high-level optimization is performed on the Julia AST before generating LLVM code. In particular a dynamic dataflow-based type inference pass is done on the Julia AST. Since Julia is homoiconic, this type inference pass can be implemented in Julia itself, which may be why you missed it: https://github.com/JuliaLang/julia/blob/master/base/inferenc.... Don't be fooled by the briefness of the code – Jeff's dynamic type inference algorithm is one of the most sophisticated to be found anywhere; see http://arxiv.org/pdf/1209.5145v1.pdf for a more extensive explanation. It's also highly effective: 60% of the time it determines the exact type of an expression and most of the expressions which cannot be concretely typed are not performance critical [see section 5.2 of the same paper]. You are correct that we leave machine code generation to LLVM – after all, that's what it's for – but without all that type information, there's no way we could coax LLVM into generating good machine code. Other very important optimization passes done on the Julia AST include aggressive method inlining and elimination of tuple allocation. > more succintly, Julia lacks a clear enough thoughtful choice in static/dynamic semantics for the pre LLVM side to have an easy optimization story given a small sized core team, such optimization engineering will either take a long time to develop, or will require some commercial entity to sink serious capital into writing a good JIT / optimizer. There is a very clear and thoughtful choice in static vs. dynamic semantics in Julia: all semantics are dynamic; there are no static semantics at all. If you think about your code executing fully dynamically, that is exactly how it will behave. Of course, to get good performance, the system figures out when your code is actually quite static, but you never have to think about the distinction. And again, Julia already has excellent performance, and we have accomplished that with an admittedly tiny and relatively poorly funded team. (All the money in the world won't buy you another Jeff Bezanson.) > also: Julia doesn't have a type system, it has a dynamic check system. (Show me the code for static type check in the julia code base as it exists on github and I'll owe you a beer :) ) The academic programming language community has gradually narrowed their notion of what a type is over the past decades to the point where a type system can only be something used for static type checking. Meanwhile, the real world has gone full throttle in the other direction: fully dynamic languages have become hugely popular. So yes, if you're a programming language theorist, you may want to insist that Julia has a "tag system" rather than a "type system" and other type theorists will nod their heads in agreement. However, the rest of the world calls the classes of representations for values in dynamic language like Python "types" and understands that a system for talking about those types – checked or not – qualifies as a type system. So, while you are correct that Julia doesn't do any static type checking, it is still understood to have what most people call a "type system". [There's actually an important point of programming language philosophy here: one of the premises of Julia is that static type checking isn't actually the main benefit that's brought to the table by a type system. Rather, we leverage it for greater expressiveness and performance, leaving type checking on the table – for now. This emphasis doesn't mean that we can't add some type checking later – since we can infer exact types 60% of the time, we can check that those situations don't lead to errors. We can also provide feedback to the programmer about places where they could improve the "staticness" of their code and get better performance or better "checkability". This let's the programmer use a dynamic style for prototyping and gradually make their program more and more static as it needs to be faster and/or more reliable.] > Let me repeat: Julia doesn't have clear static semantics / phase distinction, and doesn't really seem to do anything beyond method specialization before passing code on to LLVM. This means it can't get compelling performance compared with any other LLVM backed language. I'll repeat myself a bit too. Julia has a very clear static semantics – there are none. The run-time does quite a bit of analysis and optimization after method specialization (aggressive run-time method specialization is incredibly important, however, so one shouldn't discount it). And, of course, Julia already has compelling performance compared with other languages, both static and dynamic, in benchmarks and real-world applications.
In Show HN: I'm building an open-source, high-frequency trading system
The type system is actually one of the key features for this. Systems like NumPy are essentially a way of grafting a type system onto Python arrays. Julia's design allows Array to be be a completely generic parametric type, but when specialized as Array{Float64} or Array{Int64} it is memory-compatible with C, Fortran and NumPy. As a result, Arrays can be shared between Julia, C, Fortran and NumPy without any data copying. Another feature that's very useful for technical computing is the ability to easily create user-defined numeric types with storage and performance that's just as good as Julia's built in types (which are actually also just defined in Julia). They can also easily be made to interact completely transparently with other numeric types. A very simple example can be found here: https://github.com/JuliaLang/julia/blob/master/ex
Read the rest
amples/modi... These 13 lines of code define a modular integer type that has the same storage and speed as regular integers, but with modular behavior, and interoperates with normal integers (i.e. `1 + ModInt{11}(1234)` works). Because of generic programming, you get matrices of ModInts for free, again with performance like plain old integers but different behavior. The same applies to defining new representations of things like matrices or dicts.
In Videos from the Julia tutorial at MIT

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.