The shortest possible answer is that it’s fast because it was designed to be fast.
Any programming language (implementation) can be fast if it does certain things:
Uses numeric types which are natively supported by the machine (i.e. not arbitrary-precision numbers), which can then be used with hardware arithmetic operations directly, costing only one machine instruction per operation. (or even less with SIMD)
Puts data inline in arrays to avoid the cost of indirection and get the most out of the CPU cache. Inline numeric data is also necessary for SIMD.
Avoids frequent memory allocation from the heap. Modern processors can optimize stack allocation, but heap allocation involves rather costly system calls. It is partially the responsibility of the programmer to handle this, but the language also plays a big part in allowing (or not) the amortization of allocation costs. Inline data in arrays also means that storage is allocated in advance.
Interoperates well with pre-existing high-performance libraries—usually with a C-FFI (C foreign function interface).
Julia does all of these things—or at least, it does three of these things, and it makes it possible to avoid allocation as well, though naive Julia may do frequent memory allocations (just as naive C++ may do frequent memory allocations).

You might be surprised to learn that many programming languages are not designed with performance in mind, but rather are designed to present the programmer with a certain set of abstractions and then try to implement the language to be as performant as possible around the predetermined abstractions. High-performance languages, on the other hand, are designed for 
performance first and select abstractions that fit that.
.......................