Whilst Julia's foreign function interface is indeed good and it is really easy to call into C, the point is that Julia itself is as fast as C. So you don't need to write any C code to get performance, instead just tune the bottlenecks in Julia itself.
For instance, the standard library of Julia [1] is written in Julia itself (and is very performant) and only calls into external C or Fortran libraries where there are well established code-bases (e.g. BLAS, FFTW). Compare this to, e.g., Python or R where much of the standard library is written in C.
[1] https://github.com/JuliaLang/julia/tree/master/base
In A Look at How Traders and Economists Are Using the Julia Programming LanguageJuliaLang
julia
Julia2012–2026
JuliaLang / julia
julia
The Julia Programming Language
178Distinct people
335Mentions
5Explicit recommenders
49.3KGitHub stars
What to know before exploring
What it is
The Julia Programming Language
GitHub
Where it is used
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
- juliastats/distributions.jl · linked in 3 of the same discussions
- juliastats/statsbase.jl · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 10:01:16 PM 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.
* 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
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2012 | 2012-01-01 00:00:00 UTC | 2013-01-01 00:00:00 UTC | 12 | 1 | 11 |
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 13 | 1 | 12 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 42 | 7 | 35 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 26 | 4 | 22 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 26 | 4 | 22 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 19 | 5 | 14 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 29 | 5 | 24 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 31 | 4 | 27 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 22 | 3 | 19 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 37 | 2 | 35 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 38 | 1 | 37 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 22 | 4 | 18 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 8 | 0 | 8 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 6 | 0 | 6 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 4 | 1 | 3 |
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 GitHubWhat Hacker News says
26 sources> which we desperately want to get rid of
Would that be covered by https://github.com/JuliaLang/julia/pull/18632 or is it a separate issue? I have some really ugly code that ought to be built out of nested generators, but I can't afford the millions of heap allocations.
In Julia 0.5 HighlightsIf you're really curious, you can follow some of the breadcrumbs through the "Activate LLVM 3.7" GitHub issue (which was originally started for version 3.5).
https://github.com/JuliaLang/julia/issues/9336
In Julia 0.5 HighlightsOptionally. OpenBLAS and LAPACK are the default.
See here: https://github.com/JuliaLang/julia
OpenBLAS — fast, open, and maintained basic linear algebra subprograms (BLAS) library, based on Kazushige Goto's famous GotoBLAS.
LAPACK (>= 3.5) — library of linear algebra routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems.
MKL (optional) – OpenBLAS and LAPACK may be replaced by Intel's MKL library
In The Julia Programming Language for Number CrunchingQuite a milestone for Julia, and an important step forward towards stability as well: I believe a core Julia team member (Viral Shah IIRC) said that there would be only one or two major releases between 0.5 and 1.0.
One thing I like about Julia development is how receptive they are to community ideas, while also making sure the suggestions fit into the larger pattern and rejecting those that don't. (The "Support for arrays with indexing starting at values different from 1" thing does worry me, since it has the potential to screw things up gloriously, but it seems[1] they predicted HN will gnaw at this one. :) And I'm yet to read the whole of that issue, maybe it'll end up convincing me it's a good idea.)
[1] https://github.com/JuliaLang/julia/pull/16260
In Julia v0.5.0 ReleasedSee https://github.com/JuliaLang/julia/issues/18374#issuecomment.... Open-source Julia builds also need to support non-Intel processors and architectures, and operating systems where MKL isn't available.
If you have a specific operation where MKL is noticeably faster than OpenBLAS, report it. OpenBLAS can always be improved if they have specific workloads to target.
In Julia 0.5 releaseA better link is: https://github.com/JuliaLang/julia/blob/release-0.5/NEWS.md
Better yet, wait for the official announcement once binaries are compiled and posted for download. I believe there will be a blog post to go along with it, too.
In Julia 0.5 releaseIt already has!
This comment -- https://github.com/JuliaLang/julia/issues/3721#issuecomment-...
In How a comment on Hacker News led to 4½ new Unicode charactersWill this eventually solve the "Julia does not like Pizza" issue (https://github.com/JuliaLang/julia/issues/3721)?
In How a comment on Hacker News led to 4½ new Unicode charactersSupport for 0-indexed and arbitrary-indexed arrays
1 points · Open discussionFair enough, but the appeal of Lisp to me is that it's a small axiomatic core, something that not only fits in your head, but the whole implementation fits in your head too. I wanted to use it to bootstrap languages, with no dependencies.
But it turns out that this axiomatic core is too impoverished for a lot of programming. You DO need something like Common Lisp on top. And I'm not really willing to open that can of worms, both for this specific project, and in general.
I would liken it to the language "Factor", which I've also experimented with... you took a specific and elegant paradigm, and tried to extend it to all paradigms, and ended up with a mess. A square peg in a round hole. Factor is basically Forth with OOP and a whole bunch of other stuff.
The other problem I pointed out is that the first problem you hit when writing a
Read the rest
language is writing a lexer. I don't see anything that Lisp offers you in that respect. I looked at how Julia does it:
https://github.com/JuliaLang/julia/blob/master/src/julia-par...
Julia is actually bootstrapped in femtolisp. If you look at the lexer, it just looks like C code written with Scheme syntax. There's nothing helpful about this. It doesn't help you manage state. I might as well just write C.
(And actually I chose the code generator re2c, which is BETTER than C.)
Showing the 15 most recent of 26 sources. Enable JavaScript to search and browse every indexed mention.