Julia
This is a list of resources and articles about the Julia language.
Jump to: Documentation • Libraries • Other
News
15/2/2025 16:51 Asynchronous programming in Julia: Deep and detailed study in the form of a notebook.
29/7/2024 10:53 Geospatial Data Science with Julia: “best practices for writing clean, readable and performant code in geoscientific applications involving sophisticated representations of the (sub)surface of the Earth such as unstructured meshes made of 2D and 3D geometries.” Open source and CC licensed.
2/4/2023 10:30 Solving one based indexing: Finally, a solution to the non-problem of 1-based indexing in Julia that should satisfy everybody.
18/3/2023 10:19 Practical guide: how to contribute to open source Julia projects: This is helpful for those interested in making their first contribution to the ecosystem.
16/11/2022 8:41 Introducing Braket.jl - Quantum Computing with Julia: “Braket.jl is a new, experimental package that lets you build quantum circuits and programs in Julia and run them on Amazon Braket.”
11/3/2022 11:55 Julia v1.8 Release Notes: Julia 1.8.0 is in beta. These release notes include many welcome enhancements. Several of the new features relate to the creation of sysimages, and appear to make it easier to produce smaller compiled code.
22/1/2022 12:53 Pluto 0.17.6 Announced: The latest version of Pluto, the computational notebook for Julia, has some great new features, including a dark mode and the ability to print logging messages from running code in the notebook.
5/9/2021 10:08 optimizer: supports callsite annotations of inlining: fixes #18773
6/5/2021 20:44 ModelingToolkit.jl: “A modeling framework for automatically parallelized scientific machine learning (SciML) in Julia. A computer algebra system for integrated symbolics for physics-informed machine learning and automated transformations of differential equations”.
22/4/2021 12:04 Dataframes.jl reaches v. 1.0: The powerful data-wrangling package passes a milestone.
6/3/2021 8:31 Announcing Symbolics.jl: A Modern Computer Algebra System for a Modern Language: “We need new Computer Algebra Systems (CAS) for this new era of computing. We need a CAS that dispatches in the multiple ways we think. We need a CAS that scales exponentially like our problems. We need a CAS that integrates with our package ecosystem, letting people extend parts and contribute back to the core library all in one language. We need a modern CAS in a modern language.”
4/1/2021 9:59 Typed vs. Untyped Dict Performance in Julia: An interesting case study showing a massive speedup and reduction in memory allocation gained from a type declaration.
3/11/2020 10:00 An Introduction to Pluto: Pluto is a new computational notebook for the Julia programming language.
20/8/2020 12:56 The JuliaMono Typeface: 
Today I learned that Julia has its own typeface. It has huge Unicode coverage, with 10,028 glyphs.
Today I learned that Julia has its own typeface. It has huge Unicode coverage, with 10,028 glyphs.
23/7/2020 1:08 The Top Programming Languages: Julia is #19, breaking into the top 20 for the first time.
1/6/2018 14:46 Julia Keeps Getting Better: As release 1.0 of the numerical/scientific language Julia was approaching, here was one man’s list of favorite new features.
7/7/2014 14:07 GraphLayout.jl: “Graph layout algorithms in pure Julia. Currently only has the spring-based method of Fruchterman and Reingold (1991), but more can and will be added.”
Documentation and tutorials
Python Criticism from a Julia Perspective: Contains, among other interesting nuggets, a description of a Julia REPL facility for discovering a list of methods that can act on a given combination of types (I had no idea).
Julia macros for beginners: A clear introduction.
Triangle frenzy: A case study using CUDA for some graphics calculations.
Differentiation for Hackers: “The goal of this handbook is to demystify algorithmic differentiation, the tool that underlies modern machine learning.”
DataFrame vs NamedTuple: a comparison: Informative comparison of the use of dataframes vs. named tuples to represent tables in Julia, with interesting examples of fast and slow code.
Julia as a cli calculator: Beautifully done and super useful article about using Julia as a calculator for arrays (but contains so much more).
Julia for Python Programmers: Although Julia is not very close to Python, this might be a useful reference for a Python programmer beginning the upgrade process.
Mastering Efficient Array Operations with StaticArrays.jl in Julia: Good tutorial with benchmarks.
Learning to create a vector in Julia: Two ways to turn a multidimensional array into a Vector in Julia: one that makes a copy and one that uses an alias.
Julia Express: Summary of Julia syntax (pdf). Updated: 12Aug2018.
What does it mean that a data frame is a collection of rows?: The main developer of Dataframes.jl explains its interface in this illuminating article.
Why I Wrote a Julia Programming Book: Julia as a general-purpose language, and as a good choice for teaching.
Pkg.jl and Julia Environments for Beginners: Exceptionally clear tutorial about Julia’s package manager.
PlutoUI Demonstration: A live demonstration of PlutoUI controls, served with the PlutoSliderServer.
Data Science in Julia for Hackers: “This book is currently in a beta version. We are looking forward to getting feedback and criticism”.
What is a Symbol in Julia?: Stefan Karpinski’s masterful explanation of what a Symbol really is.
Convolutions in image processing: Not much about Julia, but a superb demonstration of how simple convolutions can create blurring, sharpening, and edge detection. Ends by showing how to speed up the calculation using FFTs.
Comparison of plotting packages: Newcomers (and others!) using Julia can be bewildered by the profusion of options for making plots and visualizations. Chris Rackauckas provides a useful summary of the pros and cons of all the major packages.
HPC Cafe: An introduction to the Julia programming language for HPC: This video is packed with insights about high performance computing with Julia, and is easy to follow.
Fast as Fortran, Easy as Python: An introduction to Julia in Linux Pro Magazine.
How do Recipes actually work?: This is a great resource for quickly coming up to speed with plot recipes. It has useful examples and explains how things work under the hood.
Fundamentals of Numerical Computation: “This is a revision of the textbook Fundamentals of Numerical Computation by Tobin A. Driscoll and Richard J. Braun. The book was originally written for MATLAB, but this resource has been adapted to suit Julia.” Text available free online.
Storing vectors of vectors in DataFrames.jl: Extremely useful tutorial on preventing vectors from being expanded into multiple rows when applying transformations to dataframes.
Julia, Matlab, R, Python Cheatsheat: Convenient table comparing (mostly) matrix operations among these languages (left out APL).
Multi-node Parallelism in Julia on an HPC (XSEDE Comet): “Today I am going to show you how to parallelize your Julia code over some standard HPC interfaces.”
Visualize Squirmers: ‘The visualization shown here is based on simulation data generated as part of the work “Modeling a spheroidal microswimmer and cooperative swimming in a narrow slit”.’
Using Julia on the HPC: A survey of simple examples of using Julia in HPC contexts.
How to Create Software Packages with Julia Language: “This article will teach you how to create an open-source software package in the Julia programming language and develop your package using Git-based workflows.” This tutorial is a detailed and gentle on-ramp to the subject.
Ditch Excel and Use Julia Data Frames: A really useful tutorial showing how to use Julia to parse and analyse data from a CSV file.
Multithreading in Julia Language Applied to Cell Lists Algorithm: “This article teaches you how to use multithreading in Julia Language to parallelize serial algorithms. As a practical example, we explore how to convert the serial Cell Lists algorithm”.
Julia Data Science: A free and open-source book in several formats, including a paperback on amazon. Confined mainly to a brief language introduction, dataframes, and plotting with Mackie.
Diagramming and Data Visualization with Julia: I didn’t know about Vizagrams.jl, an interesting Julia library for plotting and data visualization. It implements a kind of grammar of graphics, and looks powerful.
Writing type-stable Julia code: Using many examples, this tutorial will help you understand how to do what’s in the title.
My understanding of object property access in Julia: Clarifies the use of fields and properties of composite objects.
The Julia Package Manager: A brief introduction to packages, environments, and making your own package.
Julia 1.0 Documentation: The official source.
MicroGrad.jl: Part 1 ChainRules: An extensive tutorial on automatic differentiation in Julia in the context of machine learning.
PrecompileTools.jl: Documentation and tutorials for PrecompileTools.jl, which “is designed to help reduce delay on first usage of Julia code. It can force precompilation of specific workloads…You can use PrecompileTools as a package developer, to reduce the latency experienced by users of your package for ‘typical’ workloads; you can also use PrecompileTools as a user, creating custom ‘Startup’ package(s) that precompile workloads important for your work.”
Metaprogramming in Julia: A Jupyter notebook showing some numerical applications of macros.
GPU Programming: When, Why and How?: This course on using GPUs in general computing contains a section (“High-level language support”) with an overview of Julia and Python.
Six Months With Julia: Parse-time Transpilation in 80 Lines or Less: A case study in applying Julia’s string macros to allow it to read a different language.
Using the FFTW Library in Julia: A useful tutorial.
Ref ref: “Today I want to discuss the Ref type defined in Base Julia. The reason is that it is often used in practice, but it is not immediately obvious what the design behind Ref is.”
Functional One-Liners in Julia: Introduction to currying used in conjunction with broadcasting, with examples.
Parallel Computing and Scientific Machine Learning (SciML): Methods and Applications: “This book is a compilation of lecture notes from the MIT Course 18.337J/6.338J: Parallel Computing and Scientific Machine Learning…a live document, updating to continuously add the latest details on methods from the field of scientific machine learning and the latest techniques for high-performance computing.”
A quick introduction to data parallelism in Julia: “If you have a large collection of data and have to do similar computations on each element, data parallelism is an easy way to speedup computation using multiple CPUs […] A major hurdle for using data parallelism is that you need to unlearn some habits useful in sequential computation […] In particular, it is important to use libraries that help you describe what to compute rather than how to compute. Practically, it means to use generalized form of map and reduce operations and learn how to express your computation in terms of them. Luckily, if you already know how to write iterator comprehensions, there is not much more to learn for accessing a large class of data parallel computations.”
Julia Books: A list from Julia headquarters of works available now or on the way.
Running Shell Commands from Julia: The Julia[@julia] language has unusually convenient mechanisms for interacting with the shell and gluing code together. Here’s a useful tutorial.
Bayesian Estimation of Differential Equations: Tutorials showing how to use Turing.jl to estimate parameters of ODEs from data.
Guide for writing shell scripts in Julia: From 2019, but may still be useful.
Signal Processing with Julia Language: A tutorial series.
Particle Simulations with Julia: Excellent tutorial and demonstration available as a web page and as a Pluto notebook. Contains fascinating animations of error propagation in a running simulation.
JuliaLang Antipatterns: “An antipattern is a common solution to a problem that over-all makes things worse than they could have been. This blog post aims to highlight a few antipatterns common in Julia code. I suspect a lot of this is due to baggage brought from other languages, where these are not Antipatterns, but are in fact good patterns. This post is to clear things up.”
Successful Static Compilation of Julia Code for use in Production: “a successful experiment to statically compile a piece of Julia code into a small
.so library on Linux, which is then loaded from Python and used in training of a deep learning model.”
Julia for Beginners: “A beginner-friendly guide to the Julia programming language. […] This book engages the reader with fun programming examples involving building and launching a rocket, implementing simple encryption algorithms used by Roman armies, and simulating a mechanical calculator.”
Julia: Learn the New Language for Scientific Computing: My introduction to Julia in Linux Format, available for subscribers to the magazine.
Metadata in DataFrames.jl: why and how?: Valuable and detailed introduction to this useful feature of DataFrames.jl, by one of its developers and the author of Julia for Data Analysis.
Setting up your Julia session: A tutorial about the Julia startup file.
My approach to named tuples in Julia: “I find it more natural to think of a NamedTuple as an anonymous struct, that optionally can be integer-indexed to get access to its components.”
Filtering grouped data frames in DataFrames.jl: A helpful tutorial by Bogumił Kamiński.
Functional One-Liners in Julia: A clear tutorial with illustrative examples.
IdSet in Julia 1.11: A new public type in Julia 1.11 and what it’s good for. As a bonus, a useful summary of Julia’s various equality tests.
Think Julia: How to Think Like a Computer Scientist: “This book is for anyone who wants to learn to program. No formal prior knowledge is required.” Free to read at the link; a print version is also available.
PSA: Thread-local state is no longer recommended: “Any code that relies on a specific threadid staying constant, or on a constant number of threads during execution, is bound to be incorrect.”
Julia Meta Types: “One of my favorite tools and a double edged blade in the Julia programming language are Meta Types. Loosely related to Metaprogramming, meta types, derived from the Greek word μετα, ‘transcend’ beyond a simple data structure. Rather than simply describe a physical data structure in memory, a meta type includes information on the type itself.”
Julia By Example: Learn basic Julia syntax by example, plus four plotting packages and a taste of DataFrames.
Julia: The Greeks and Math operators at the command line via LaTeX: If you haven’t tried Julia, this may whet your appetite.
Type-Dispatch Design: Post Object-Oriented Programming for Julia: “I am going to try to explain in detail the type-dispatch design which is used in Julian software architectures. It’s modeled after the design of many different packages and Julia Base […] Julia is built around types. Software architectures in Julia are built around good use of the type system. This makes it easy to build generic code which works over a large range of types and gets good performance. The result is high-performance code that has many features. In fact, with generic typing, your code may have more features than you know of! The purpose of this tutorial is to introduce the multiple dispatch designs that allow this to happen.”
Libraries
Handcalcs.jl: “This package supplies macros to generate LaTeX formatted strings from math[e]matical formulas.” For use in Pluto.
Tidier.jl: “Tidier.jl is a data analysis package inspired by R’s tidyverse and crafted specifically for Julia.”
Agents.jl: A Julia package for agent-based modeling. Very easy to set up simulations on a variety of spaces, including Open Street Map.
VegaLite.jl: Julia bindings to Vega-Lite: “VegaLite.jl is a plotting package for the julia programming language. The package is based on Vega-Lite, which extends a traditional grammar of graphics API into a grammar of interactive graphics.”
CSV: A powerful package for dealing with data stored in comma (or any delimiter) separated value files.
PGFPlotsX.jl: Create plots in Julia using the PGFPlots LaTeX package: “PGFPlotsX is a Julia package to generate publication quality figures using the LaTeX library PGFPlots.”
JuliaAstroSim/AstroNbodySim.jl: “Unitful and differentiable gravitational N-body simulation code in Julia”.
JuliaSymbolics: “JuliaSymbolics is the Julia organization dedicated to building a fully-featured and high performance Computer Algebra System (CAS) for the Julia programming language.”
Nemo: A computer algebra package for the Julia programming language.
APL.jl: APL in Julia, with all the beautiful characters, and with Julia’s speed.
DifferentialEquations.jl: “Multi-language suite for high-performance solvers of differential equations and scientific machine learning (SciML) components”.
ImplicitPlots.jl: Julia package for the plotting of plane curves and surfaces: “Plot plane curves defined by an implicit function f(x,y)=0.”
Turing.jl: “Bayesian inference with probabilistic programming.”
ChunkSplitters.jl: “ChunkSplitters.jl makes it easy to split the elements or indices of a collection into chunks…this can be useful in many areas, one of which is multithreading, where we can use chunking to control the number of spawned tasks”.
Swalbe.jl: A lattice Boltzmann solver for thin film hydrodynamics: A Julia program.
Bayesian Statistics using Julia and Turing: “Welcome to the repository of tutorials on how to do Bayesian Statistics using Julia and Turing.”
Tensorial: “Tensorial.jl provides statically sized Tensor type that is compatible with AbstractArray, similar to SArray from StaticArrays.jl. In addition to supporting basic AbstractArray operations, the package offers a tensorial interface and several advanced features”.
Introduction to GRUtils: “GRUtils is a refactoring of the module jlgr from GR, a graphics package for Julia. The purpose of GRUtils is to provide the main utilities of jlgr in a more ‘Julian’ and modular style, easier to read, and facilitate code contributions by others.”
Trixi.jl: “Trixi.jl is a numerical simulation framework for conservation laws written in Julia. A key objective for the framework is to be useful to both scientists and students. Therefore, next to having an extensible design with a fast implementation, Trixi.jl is focused on being easy to use for new or inexperienced users, including the installation and postprocessing procedures.”
PlutoSliderServer.jl: Web server to run just the
@bind parts of a Pluto.jl notebook.
Announcing Gnuplot v1.1.0 - A Julia interface to gnuplot: “the first production ready version of Gnuplot.jl, a package to drive an external gnuplot 16 process from Julia.”
PlanetOrbits.jl: Tools for solving and displaying Keplerian orbits for exoplanets.: “The primary use case is mapping Keplerian orbital elements into Cartesian coordinates at different times. A Plots.jl recipe is included for easily plotting orbits.”
Oceananigans.jl: 
“Fast and friendly fluid dynamics on CPUs and GPUs”
“Fast and friendly fluid dynamics on CPUs and GPUs”
SciML: Differentiable Modeling and Simulation Combined with Machine Learning: A new hub for Julia’s SciML documentation.
Changing Physics education with Julia: Interactivity in physics education; why Julia is an ideal language for physics education; applied to teaching dynamical systems and the DynamicalSystems library, of which the author is the maintainer, and his textbook.
TerminalPager.jl: This lovely package, announced April 19th, 2021, lets you page horizontally and vertically through a dataframe in the REPL, sort of like paging through a file with
less.
Revise.jl: Automatically update function definitions in a running Julia session: “Revise.jl allows you to modify code and use the changes without restarting Julia. With Revise, you can be in the middle of a session and then update packages, switch git branches, and/or edit the source code in the editor of your choice; any changes will typically be incorporated into the very next command you issue from the REPL. This can save you the overhead of restarting Julia, loading packages, and waiting for code to JIT-compile.”
EmacsVterm.jl: “Better integration of Julia REPL with Emacs vterm terminal.”
How the Julia language is making it easy for programmers to use GPU capabilities with JuliaGPU: An interview with Tim Besard, a principal contributor to JuliaGPU.
Oxygen.jl: “Oxygen is a micro-framework built on top of the HTTP.jl library. Breathe easy knowing you can quickly spin up a web server with abstractions you’re already familiar with.” Supports streams and websockets.
Bonito: “Bonito.jl is a pretty simple package allowing you to render HTML and serve it from within Julia and build up a communication bridge with the Browser.”
JLD.jl: Saving and loading julia variables while preserving native types: The Julia Data Format is a dialect of HDF5.
Distributions Package: “The Distributions package provides a large collection of probabilistic distributions and related functions.”
Pluto’s built-in package management: “Starting with version 0.15, Pluto has a built-in package manager, which means:
- Packages are automatically installed when you use import or using.
- Your package environment is stored inside the notebook file. When someone else opens your notebook with Pluto, the exact same package environment will be used, and packages will work on their computer.
JuliaFolds/Folds.jl: A unified interface for sequential, threaded, and distributed fold: Powerful, convenient, does what it’s supposed to do.
DEC2D.jl: Discrete Exterior Calculus 2D
PyPlot: An interface to Python’s Matplotlib.
Weave.jl: Scientific reports/literate programming for Julia: “Weave is a scientific report generator/literate programming tool for the Julia programming language. It resembles Pweave, knitr, R Markdown, and Sweave.”
SuiteSparseGraphBLAS.jl: An Introduction: “This blog post serves a couple purposes. The first is to introduce Julia users to GraphBLAS, and the features and performance of the
SuiteSparseGraphBLAS.jl package. The second is an update on new features in versions 0.6 and 0.7 as well as a roadmap for the near future.”
WebAssemblyCompiler: Compile Julia programs to run in a web browser. Experimental code.
TensorCast.jl: It slices, it dices, it splices!: “This package lets you work with multi-dimensional arrays in index notation, by defining a few macros which translate this to broadcasting, permuting, and reducing operations.”
TikzGraphs: Exploiting the superb TikZ system from Julia to create high-quality graph diagrams (“graph” in the node-edge sense) conveniently.
Gnuplot.jl: Julia interface to gnuplot: This is a very well-thought-out way to use gnuplot from Julia (you need gnuplot installed), giving you the best of both worlds. For (the excellent) documentation, go to the
docs/src folder and browse the .md files, starting with basic.md.
Pandoc.jl: Pandoc Interface and Types in Julia: Run Pandoc and write Pandoc filters in Julia. Uses the json serialization, so won’t be as fast as Lua filters.
Escher: Webserving with Julia: “With Escher you can build beautiful Web UIs entirely in Julia.” Includes a built-in webserver.
SpeedyWeather: “a global spectral atmospheric model with simple physics which is developed as a research playground with an everything-flexible attitude as long as it is speedy…Why another model? You may ask. We believe that most currently available are stiff, difficult to use and extend, and therefore slow down research whereas a modern code in a modern language wouldn’t have to.”
Strided.jl: Make broadcast operations faster.
Downloads.jl: “The Downloads package provides a single function, download, which provides cross-platform, multi-protocol, in-process download functionality implemented with libcurl.” This is now used by the package manager to retrieve packages.
Stipple: A reactive user interface library for use with Genie. Standard use is over a websocket, somewhat similarly to Phoenix Liveview. Seems quite useful for building interactive web applications with Julia, but Unfortunately undocumented, like most Julia packages.
PairPlots.jl: Julia package for making corner plots, the statistical visualization that lets you compare a collection of distributions all at once.
LieGroups.jl: Lie groups and Lie algebras. Announcement on the Julia Discourse.
PipelessPipes.jl - Even More Convenient Piping: “it allows to omit pipe operators, it implicitly assumes first argument piping if not otherwise stated explicitly, it allows for more helpful error highlighting and enables you to interject arbitrary statements into the pipeline for debugging.”
My Julia Book is in Libraries: giving me a warm feeling.
PlutoUI.jl: Convenient Julian wrappers for HTML input controls, for use with Pluto.
Term.jl: “Term.jl is a Julia library for producing styled, beautiful terminal output.” It can also create input widgets.
Merly.jl: Micro framework for web programming in Julia: Seems similar to Oxygen, but hasn’t been updated since about 2020.
Javis.jl: Julia Animations and Visualizations: Animation library, still in early stages of development. An interesting feature is LaTeX support.
Interact.jl: Interactive widgets to play with your Julia code: For use in Jupyter notebooks, the Atom IDE, or on web pages.
StructuralVibration.jl: “This Julia package is intended to provide a set of tools for generating vibration data either to validate new numerical methods or to serve as input data for solving inverse problems such as input state estimation via Bayesian filtering, Bayesian regularization, machine learning, etc.”
Weave.jl - Scientific Reports Using Julia: Weave is a scientific report generator/literate programming tool for Julia. It resembles Pweave, knitr, R Markdown, and Sweave.
Reel.jl: computations caught on camera: Easily turn your Plots.jl or other plots into movies in several formats.
Here’s why quantum computing could be the big break for the Julia Language: Introducing Yao.jl, a Julia library for quantum computing.
Fermions.jl: New Julia physics library: “Fermions.jl is a toolkit for designing and analysing second-quantised many-particle Hamiltonians of electrons, potentially interacting with each other.”
GeoStats.jl: “An extensible framework for geospatial data science and geostatistical modeling fully written in Julia.” Also see the book.
GridWorlds.jl: Help! I’m lost in the flatland!: “A package for creating grid world environments for reinforcement learning in Julia.“ Juliacon presentation here.
GitHub - yolhan83/BloodFlowTrixi.jl: This package implements 1D and 2D blood flow models for arterial circulation using Trixi.jl, enabling efficient numerical simulation and analysis.: BloodFlowTrixi.jl is a Julia package that implements one-dimensional (1D) and two-dimensional (2D) blood flow models for arterial circulation.
PureFun.jl: Immutable containers for Julia.
OhMyThreads: “OhMyThreads.jl is meant to be a simple, unambitious package that provides user-friendly ways of doing task-based multithreaded calculations in Julia. Most importantly, with a focus on data parallelism, it provides an API of higher-order functions (e.g. tmapreduce) as well as a macro API
@tasks for … end (conceptually similar to @threads).”
FunSQL.jl: Julia library for compositional construction of SQL queries’
JuliaHEP: High energy physics packages. Includes compatibility layers and partial replacements for ROOT.
KittyTerminalImages: If you use the superb Kitty terminal emulator, this package is for you. It lets Julia display images directly in the terminal, using the Kitty protocol (not sixel, etc.).
waterlily.jl: “A differentiable and backend-agnostic Julia solver to simulate incompressible viscous flow and dynamic bodies”.
Oxygen.jl: A breath of fresh air for programming web apps in Julia: A micro-framework that provides routing and request/response handling.
Javis: “an easy to use interface written in Julia to create visualizations and animations”.
DBCollections.jl: Lets you “use the exact same code to manipulate regular Julia collections and SQL databases.” This will be immediately useful: data persistence, using arrays not limited by RAM, and more.
Microstructure.jl: “Microstructure.jl is a Julia package for fast and probabilistic microstructure imaging… under active development…ocuses on tissue microstructure estimation.”
About.jl: Provides the
about function, which prints attractively formatted information about any object.
RangeArrays.jl: “Efficient and convenient array data structures where the columns of the arrays are generated (on the fly) by Ranges.”
Measurements.jl: “Error propagation calculator and library for physical measurements. It supports real and complex numbers with uncertainty, arbitrary precision calculations, operations with arrays, and numerical integration.”
ImageClipboard.jl: Copy & Paste images with Julia
Gadfly: “Gadfly is a plotting and data visualization system […] influenced heavily by Leland Wilkinson’s book The Grammar of Graphics and Hadley Wickham’s refinment of that grammar in ggplot2.”
Yao: “Welcome to Yao, a Flexible, Extensible, Efficient Framework for Quantum Algorithm Design. Yao (幺) is the Chinese character for normalized but not orthogonal.”
RCall.jl: Call R packages from within Julia.
tullio: “Tullio is a very flexible einsum macro. It understands many array operations written in index notation”.
DynamicQuantities.jl: Type stable units in Julia: Along the lines of Unitful, but storing dimensions as values rather than as parametric types. This leads to greater efficiency in many circumstances.
ThreadPools: A set of macros for concurrency. Last updated around 2021; some of its function is provided by the new interactive task feature in Julia 1.9.
BioJulia: The bioinformatics infrastructure for the Julia language.
OhMyREPL.jl: “A package that hooks into the Julia REPL and gives it syntax highlighting, bracket highlighting, rainbow brackets and other goodies.”
StatsPlots.jl: Statistical plotting recipes for Plots.jl: A large variety of statistical visualizations, built on Plots.jl.
Welcome to OSCAR: “OSCAR is a new computer algebra system. OSCAR features functions for groups, rings, and fields as well as linear and commutative algebra, number theory, algebraic and polyhedral geometry, and more. It is built upon several well established systems for mathematical research joined via the Julia programming language.”
Books.jl: Creates books with embedded output from Julia code, using Pandoc.
Other
A Lisper’s first impression of Julia: A quite detailed and opinionated comparison of the various ways in which Julia is better or worse than Common Lisp.
Switching from Common Lisp to Julia: “A sufficiently rich parametric type system with multiple dispatch integrated into the language and supported by a JIT compiler is the secret weapon of Julia” and the core reason for the author’s adoption of the language for scientific computing.
Announcing composable multi-threaded parallelism in Julia: New in v. 1.3: a very nice task parallelism interface.
Matlab vs. Julia vs. Python: He came from Matlab but he has explored the wilderness. And he can write; not many articles about computer languages are pleasant to read.
Why I Switched to Julia: A case study of Julia used in econometrics that shows 100-fold speed increase over Python with Numpy.
JuliaCon Presentation Slides: The Julia language[@julia]’s first conference has recently wound up and the PDFs of the slide decks are available here. Just click on the topic you want to see and then on the filename to download (from 2014).
Inviscid and incompressible Navier-Stokes equations in 2D implemented in Julia and compiled to WASM: This is quite wonderful and amazing: a Julia fluid solver compiled to WASM and running in the browser. Users can create flow boundaries with the mouse.
Julia 1.0 is here: Back in 2014 I thought that Julia might become the preferred language for numerically intensive computing. It’s already made impressive inroads in this area, and the arrival of v.1.0, with its promise of a long future of non-breaking language development, can only accelerate its adoption.
2D Vortex Dynamics: Evolution of a vortex system in two dimensions. An interactive webpage using Julia.
Composability in Julia: Implementing Deep Equilibrium Models via Neural ODEs: “The SciML Common Interface defines a complete set of equation solving techniques, from differential equations and optimization to nonlinear solves and integration (quadrature), in a way that is made to naturally mix with machine learning. In this sense, there is no difference between the optimized libraries being used for physical modeling and the techniques used in machine learning: in the composable ecosystem of Julia, these are one and the same.[…] With a composable package ecosystem, the only thing holding you back is the ability to figure out new ways to compose the parts.”
Climate Modeling Alliance: “We are building a new Earth system model that leverages recent advances in the computational and data sciences to learn directly from a wealth of Earth observations from space and the ground. Our model will harness more data than ever before, providing a new level of accuracy to predictions of droughts, heat waves, and rainfall extremes.” The code is contained in a collection of Julia packages.
Extreme Multi-Threading: C++ and Julia 1.9 Integration: With Julia v.1.9 we can call Julia libraries from multi-threaded C++ programs, apparently. This article shows you how.
Julia: dynamism and performance reconciled by design: “Julia is a programming language for the scientific community that combines features of productivity languages, such as Python or MATLAB, with characteristics of performance-oriented languages, such as C++ or Fortran. […] This paper details the design choices made by the creators of Julia and reflects on the implications of those choices for performance and usability.”
Rankings of Julia books on Amazon: Graphs of Amazon’s sales ranks of their books about the Julia programming language.
Scientific computing’s future: Fortran, Julia, Clojure, and Haskell.
Julia for Biologists: “Major computational challenges exist in relation to the collection, curation, processing and analysis of large genomic and imaging datasets, as well as the simulation of larger and more realistic models in systems biology. Here we discuss how a relative newcomer among programming languages—Julia—is poised to meet the current and emerging demands in the computational biosciences and beyond. Speed, flexibility, a thriving package ecosystem and readability are major factors that make high-performance computing and data analysis available to an unprecedented degree. We highlight how Julia’s design is already enabling new ways of analyzing biological data and systems, and we provide a list of resources that can facilitate the transition into Julian computing.”
Julia in the Wild: Examples: Case studies of Julia use in science, engineering, industry, and finance.
Julialab: Julia Language Research and Development at MIT
Accuracy of tropical peat and non-peat fire forecasts enhanced by simulating hydrology: Fire forecasting using Flux.jl.
Julia Observer: Explore the Julia package registry.
Julia & JuliaHub: Advancing Innovation and Growth: Brief summary of progress in Julia adoption since 2020.
The 6th annual JuliaCon 2019 (Baltimore): A collection of videos from the conference.
Julia: A Fast Language for Numerical Computing: Julia may be the eventual successor[@foscArticle] to Fortran for high-performance scientific computing.
Julia v.1.6 release addresses latency issues: Julia’s new release turns the “time to first plot” problem into (almost) a non-issue.
From Common Lisp to Julia: A personal journey from CL to Julia from a graphics and games programmer. Interesting observations, badly in need of editing.
An Endorsement of Julia for Scientific Computing: Sebastian Nowozin finds the Julia language highly productive. The most serious obstacle now [2015] seems to be the lack of single-machine parallelism.
Bash shell completions for Julia: Bash shell completions contextually finish what you’re typing when you hit the tab key. This project tells the shell about Julia commands, to save you keystrokes.
Winston: 2D plotting: “Winston offers an easy to use
plot command to create figures without any fuss.”
Web development in Julia: A progress report.: First steps [2014].
Jupyter, Mathematica, and the Future of the Research Paper: Paul Romer shares, in a subtly written article, an instructive anecdote contrasting his experiences with proprietary vs. open source software. He is able to explain why Jupyter has taken over from Mathematica’s early lead.
What’s bad about Julia?: A sophisticated and detailed critique, concentrating especially on the type system, from the point of view of a Julia user.
Multiple Dispatch In Perl: A valuable explanation of the enhanced software extendability that multiple dispatch provides, using Perl as an example.
Great News for the Julia Language: A $600,000 grant to help get to the 1.0 release.
Forecasting the weather with neural ODEs: Using Julia to forecast the weather with machine learning techniques.
Apache Arrow 3.0.0 Release: “This is the first release to officially include an implementation for the Julia language.” The Julia work is developed in the Arrow.jl package.
Julia v1.10 Release Notes: Excellent progress, especially in package loading times. Watch for my LWN writeup, coming soon.
Comparing Julia to Performance Portable Parallel Programming Models for HPC: “Julia programs enjoys comparable performance to native C/C++ solutions.[…] Julia gets the unique opportunity to provide best-in-class performance on some of the latest hardware platforms.”
Wired article about the Julia language: There is growing excitement about this fairly new language in scientific computing circles and elsewhere. It’s nice to see some high-profile coverage in an article that traces its origins and potential. (Not everyone[@wiredJuliaCoverage-Criticism] is happy with this article.)
Computer algebra in Julia: A survey.
Concurrency in Julia: An overview of the easiest-to-approach facilities for parallel and concurrent computation in Julia, with a demonstration of the effects of a new feature: thread migration. Discussed on Hacker News.
Julia 1.5 Highlights: The new release of the most advanced language for scientific computing features significant improvements in convenience and performance.
High Performance Technical Computing in Dynamic Languages: Conference held in conjunction with SC14: The International Conference for High Performance Computing, Networking, Storage and Analysis.
PyCall.jl: “Package to call Python functions from the Julia language.”
A new non-parametric method to infer galaxy cluster masses from weak lensing: “a new, non-parametric method to infer deprojected 3D mass profiles M(r) of galaxy clusters from weak gravitational lensing observations…We provide an efficient implementation in Julia code that runs in a few milliseconds per galaxy cluster.”
Jack Dongarra, who made supercomputers usable, awarded 2021 ACM Turing prize: The creative force behind LINPACK and BLAS says that Julia is a good candidate for the next computing paradigm.
Parallel Supercomputing for Astronomy: “The Celeste research team spent three years developing and testing a new parallel computing method that was used to process the Sloan Digital Sky Survey dataset and produce the most accurate catalog of 188 million astronomical objects in just 14.6 minutes with state-of-the-art point and uncertainty estimates.”
The Design Impact of Multiple Dispatch: …As the core paradigm of Julia. Presented at Strange Loop on September 19, 2013 by Stefan Karpinski.
My Interview With Dr. Lee Phillips Regarding His Science Career, Science Writing, and Telling Science Stories: My chat at the National Portrait Gallery in Washington, DC, with Dr. Anwar Dunbar (previously released in six parts, now collected together).
Open Big Data Computing with Julia: Intel Science & Technology Center for Big Data
An introduction to the Julia language, part 2: More about Julia.
Macroeconomic Modeling: “The Federal Reserve Bank of New York publishes its trademark Dynamic Stochastic General Equilibrium models in Julia.”
Coming in Julia 1.5: Time Traveling (Linux) Bug Reporting: “If you can reproduce it on a linux machine and get us a trace from the
rr tool https://rr-project.org/, we can probably get it fixed for you very rapidly. For the uninitiated, rr is a Linux debugging tool originally developed at Mozilla by Robert O’Callahan and others. It is a tool known as a ‘time traveling debugger’ or ‘reverse execution engine’.”
Julia’s Big Problem With Namespace: Points out how
using two modules that export the same names leads to a naming conflict.
The Scientist’s Linux Toolbox: Free software for scientists in Linux Pro Magazine.
What’s the deal with Julia binary sizes?: Traces the huge decreases in the sizes of compiled binaries.
More Dots - Syntactic Loop Fusion in Julia: Impressive progress on efficiency of automatically vectorized loops using an expressive syntax.
