Big Book of Julia
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Adam Wysokiński 5519ebca86 update 18 hours ago update: 1 month ago update 18 hours ago

Big Book of Julia


Welcome to the Big Book of Julia!

The idea for Big Book of Julia is based on Big Book of R.

Created and maintained by Adam Wysokiński


This content is free to use and is licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0 License.

Language documentation

Julia Documentation

This is the official Julia documentation.


The Julia Programming Language

Alan Edelman, Viral B. Shah Julia Lightning Round

Keno Fischer Networking in Julia

Jeff Bezanson Parallel and Distributed Computing with Julia

Stefan Karpinski Metaprogramming and Macros in Julia

Miles Lubin, Iain Dunning Numerical Optimization in Julia

Steve Johnson Fast Fourier Transforms in Julia

Doug Bates Statistical Models in Julia

John Myles White Data Analysis in Julia with Data Frames

Jeff Bezanson, Stefan Karpinski Rationale Behind Julia and the Vision

Julia for Talented Amateurs

Alan Edelman Matrix Methods in Data Analysis, Signal Processing, and Machine Learning

Alan Edelman A programming language to heal the planet together: Julia

Julia Academy Courses


Blogs / Forums

Julia Computing

Julia Forem




Documentation for Pkg, Julia's package manager.


PkgDev provides tools for Julia package developers.


Reference implementation of a Julia Pkg server, providing advanced package serving and caching capabilities.


A reliable binary provider for Julia.


This repository implements the scratch spaces API for package-specific mutable containers of data.


An alternative to the @__DIR__ macro. Packages that wish to reference paths in their project directory run into issues with relocatability when used in conjunction with PackageCompiler. The @path macro provided by this package overcomes this limitation.


WinRPM is an installer for RPM packages provided by an RPM-md build system.


This is a wrapper package meant to bridge the gap for packages that want to use the LazyArtifacts stdlib as a dependency within packages that still support Julia versions older than 1.6.


This is a wrapper package meant to bridge the gap for packages that want to use the Artifacts as a dependency within packages that still support Julia versions older than 1.6.


This package is designed to make it easier for Julia packages to build binary dependencies that use CMake.


This package provides a BinDeps.jl-compatible CMakeProcess class for automatically building CMake dependencies.


Easily build binary dependencies for Julia packages.


Functionality to analyze the structure of Julia's METADATA repository.


This package, which builds on the Conda.jl package allows one to use conda as a BinDeps binary provider for Julia. CondaBinDeps.jl is a cross-platform alternative. It can also be used without administrator rights, in contrast to the current Linux-based providers.


This repository builds compiled binaries of cmake for the Julia packages that require this program to build.

Julia programming


Requires is a Julia package that will magically make loading packages faster, maybe.


Archspec is a Julia package to get access to the information provided by archspec-json, part of the Archspec project.


This package lets you capture subprocess stdout and stderr streams independently, resynthesizing and colorizing the streams appropriately.


This package contains tools for visualizing and interacting with profiling data collected with Julia's built-in sampling profiler.


FileIO aims to provide a common framework for detecting file formats and dispatching to appropriate readers/writers.


Julia is, in general, a "just-barely-ahead-of-time" compiled language. When you call a function for the first time, Julia compiles it for precisely the types of the arguments given. This can take some time. All subsequent calls within that same session use this fast compiled function, but if you restart Julia you lose all the compiled work. PackageCompiler allows you to do this work upfront — further ahead of time — and store the results for a lower latency startup.


Writing a notebook is not just about writing the final document — Pluto empowers the experiments and discoveries that are essential to getting there.


A tiny package to make html "<input>" a bit more Julian. Use it with the @bind macro in Pluto.


IJulia is a Julia-language backend combined with the Jupyter interactive environment (also used by IPython).


This package is a collection of web-based widgets. It works in Jupyter notebooks, Atom IDE, or as a plain old web page.


Revise.jl may help you keep your Julia sessions running longer, reducing the need to restart when you make changes to code.


A documentation generator for Julia. A package for building documentation from docstrings and markdown files.


This package enables the Markdown / MkDocs backend of Documenter.jl.


The CUDA.jl package is the main entrypoint for programming NVIDIA GPUs in Julia. The package makes it possible to do so at various abstraction levels, from easy-to-use arrays down to hand-written kernels using low-level CUDA APIs.


AMD GPU (ROCm) programming in Julia.


Spark.jl provides an interface to Apache Spark™ platform, including SQL / DataFrame and Structured Streaming. It closely follows the PySpark API, making it easy to translate existing Python code to Julia.


Parallelized Base functions.


Git.jl allows you to use command-line Git in your Julia packages. You do not need to have Git installed on your computer, and neither do the users of your packages!


An experimental code analyzer for Julia, no need for additional type annotations. JET.jl employs Julia's type inference to detect potential bugs.


Registrator is a GitHub app that automates creation of registration pull requests for your julia packages to the General registry.


Create and maintain local registries for Julia packages. This package is intended to provide a simple workflow for maintaining local registries (private or public) without making any assumptions about how the registry or the packages are hosted.


This library provides the @turbo macro, which may be used to prefix a for loop or broadcast statement. It then tries to vectorize the loop to improve runtime performance.


FLoops.jl provides a macro @floop. It can be used to generate a fast generic sequential and parallel iteration over complex collections.


FoldsCUDA.jl provides Transducers.jl-compatible fold (reduce) implemented using CUDA.jl. This brings the transducers and reducing function combinators implemented in Transducers.jl to GPU. Furthermore, using FLoops.jl, you can write parallel for loops that run on GPU.


Place @pipe at the start of the line for which you want "advanced piping functionality" to work. This works the same as Julia piping, except if you place a underscore in the right-hand expression, it will be replaced with the result of the left-hand expression.


The NetworkOptions package acts as a mediator between ways of configuring network transport mechanisms (SSL/TLS, SSH, proxies, etc.) and Julia packages that provide access to transport mechanisms. This allows the a common interface to configuring things like TLS and SSH host verification and proxies via environment variables (currently) and other configuration mechanisms (in the future), while packages that need to configure these mechanisms can simply ask NetworkOptions what to do in specific situations without worrying about how that configuration is expressed.


Tokenize is a Julia package that serves a similar purpose and API as the tokenize module in Python but for Julia.


A Julia frontend, written in Julia.


The purpose of the BinaryBuilder.jl Julia package is to provide a system for compiling 3rd-party binary dependencies that should work anywhere the official Julia distribution does.


Collect, symlink and copy around prefixes of JLL packages! This package makes it easy to use prefixes of JLL packages outside of Julia, either by symlinking or copying them to a stable prefix.


A general-purpose probabilistic programming system with programmable inference, embedded in Julia


Soss is a library for probabilistic programming.


WIP, successor to Soss.jl.


This package automates building of user-specific system images (sysimages) for the specific project.


NBInclude is a package for the Julia language which allows you to include and execute IJulia (Julia-language Jupyter) notebook files just as you would include an ordinary Julia file.


SoftGlobalScope is a package for the Julia language that simplifies the variable scoping rules for code in global scope. It is intended for interactive shells (the REPL, IJulia, etcetera) to make it easier to work interactively with Julia, especially for beginners.


This package makes it easy to change the "default" precision of a large body of Julia code, simply by prefixing it with the @changeprecision T expression macro.


A package that hooks into the Julia REPL and gives it syntax highlighting, bracket highlighting, rainbow brackets and other goodies.


TimerOutputs is a small Julia package that is used to generate formatted output from timings made in different sections of a program. It's main functionality is the @timeit macro, similar to the @time macro in Base except one also assigns a label to the code section being timed. Multiple calls to code sections with the same label (and in the same "scope") will accumulate the data for that label. After the program has executed, it is possible to print a nicely formatted table presenting how much time, allocations and number of calls were made in each section. The output can be customized as to only show the things you are interested in.


ArgParse.jl is a package for parsing command-line arguments to Julia programs.


A CLI package manager for Julia.


The Base package for IonCLI. This includes all the builtin functionalities in IonCLI. It can be extended by developers by overloading some of the interfaces.


Collecting packages you have commit access to.



This package provides the ability to directly call and fully interoperate with Python from the Julia language. You can import arbitrary Python modules from Julia, call Python functions (with automatic conversion of types between Julia and Python), define Python classes from Julia methods, and share large data structures between Julia and Python without copying them.


This package allows one to use conda as a cross-platform binary provider for Julia for other Julia packages, especially to install binaries that have complicated dependencies like Python.


SymPy is a Python library for symbolic mathematics.


A Julia interface for SciPy using PyCall.jl.


This module provides a Julia interface to the Matplotlib plotting library from Python, and specifically to the matplotlib.pyplot module.


PyCallJLD enables saving and loading PyCall's PyObjects using JLD.jl.


A Julia wrapper around the Seaborn data visualization library.


This package provides a Julia interface to the excellent Pandas package. It sticks closely to the Pandas API. One exception is that integer-based indexing is automatically converted from Python's 0-based indexing to Julia's 1-based indexing.


Allows the user to call R packages from within Julia.


The MATLAB.jl package provides an interface for using MATLAB® from Julia using the MATLAB C api.


Cxx.jl is a Julia package that provides a C++ interoperability interface for Julia. It also provides an experimental C++ REPL mode for the Julia REPL.



HDF5 is a file format and library for storing and accessing data, commonly used for scientific data. HDF5 files can be created and read by numerous programming languages. This package provides an interface to the HDF5 library for the Julia language.



CSV.jl is a pure-Julia package for handling delimited text data, be it comma-delimited (csv), tab-delimited (tsv), or otherwise.


DataFrames.jl provides a set of tools for working with tabular data in Julia.


Metaprogramming tools for DataFrames.jl objects to provide more convenient syntax.


This guide provides documentation around the powerful tables interfaces in the Tables.jl package.


Tools for working with metadata of Tables.jl tables in Julia.


A string type for minimizing data-transfer costs in Julia.


DataCubes provides a framework to handle multidimensional tables.


This package has the purpose to print data in matrices in a human-readable format. It was inspired in the functionality provided by ASCII Table Generator.


A collection of type parsers and utilities for Julia.


Simple, fast, column-based storage for data analysis in Julia.


YAML is a flexible data serialization format that is designed to be easily read and written by human beings. This library parses YAML documents into native Julia types and dumps them back into YAML documents.


JLD2 saves and loads Julia data structures in a format comprising a subset of HDF5, without any dependency on the HDF5 C library.


Query is a package for querying Julia data sources. It can filter, project, join, sort and group data from any iterable data source.


Read R data files (.rda, .RData) and optionally convert the contents into Julia equivalents.


A package that provides a JSON integration with the Tables.jl interface, that is, it provides the jsontable function as a way to treat a JSON object of arrays, or a JSON array of objects, as a Tables.jl-compatible source.


Package providing the StructTypes.StructType trait for Julia types to declare the kind of "struct" they are, providing serialization/deserialization packages patterns and strategies to automatically construct objects.


This package provides a namespace for data-related generic function definitions to solve the optional dependency problem; packages wishing to share and/or extend functions can avoid depending directly on each other by moving the function definition to DataAPI.jl and each package taking a dependency on it.


"Strapping" stands for STruct Relational MAPPING, and provides ORM-like functionality for Julia, including:


Common table operations on Tables.jl compatible sources.


Strategies for nested data in Julia.


Simple distributed datastore that supports custom serialization, spilling least recently used data to disk and memory-mapping.


IndexedTables provides tabular data structures where some of the columns form a sorted index.


FlatBuffers.jl provides native Julia support for reading and writing binary structures following the google flatbuffer schema.


Convenience functions for working with missing values in Julia.


The Avro.jl package provides a pure Julia implementation for reading writing data in the avro format.


Julia library for working with feather-formatted files.


JuliaDB is a package for working with persistent data sets.


JuliaDBMeta is a set of macros to simplify data manipulation with JuliaDB, heavily inspired on DataFramesMeta.


Read xBase / dBASE III+ .dbf files in Julia.


A pure Julia implementation of the apache arrow memory format specification.


This package is about interfaces to the Dataverse project APIs, collections, datasets, etc.


Yet another JSON package for Julia; this one is for speed and slick struct mapping.


This package contains the Julia binding for the chemfiles library. It allow you, as a programmer, to read and write chemistry trajectory files easily, with the same simple interface for all the supported formats. For more information, please read the introduction to chemfiles.



A pooled representation of arrays for purposes of compression when there are few unique elements.


The package provides the CategoricalArray type designed to hold categorical data (either unordered/nominal or ordered/ordinal) efficiently and conveniently.


This very small package just exports one type: the InvertedIndex, or Not for short. It can wrap any supported index type and may be used as an index into any AbstractArray subtype, including OffsetArrays.


This package for the Julia language provides an array type (the AxisArray) that knows about its dimension names and axis values.


Designs for new Base array interface primitives, used widely through scientific machine learning (SciML) and other organizations


OffsetArrays provides Julia users with arrays that have arbitrary indices, similar to those found in some other programming languages like Fortran.


StructsOfArrays implements the classic structure of arrays optimization. The contents of a given field for all objects is stored linearly in memory, and different fields are stored in different arrays. This permits SIMD optimizations in more cases and can also save a bit of memory if the object contains padding. It is especially useful for arrays of complex numbers.


IdentityRanges are Julia-language a helper type for creating "views" of arrays.


A Julia package for concatenating, growing, and shrinking arrays in ways that allow control over the resulting axes.


An IndirectArray is one that encodes data using a combination of an index and a value table. Each element is assigned its own index, which is used to retrieve the value from the value table. Concretely, if A is an IndirectArray, then A[i,j...] = value[index[i,j,...]].


This package implements "lazy" in-place elementwise transformations of arrays for the Julia programming language.


UnsafeArrays provides stack-allocated pointer-based array views for Julia.


This Julia package supports the creation of array types with "unconventional" indices, i.e., when the indices may not start at 1.


This package for the Julia language provides an array type (the AxisArray) that knows about its dimension names and axis values. This allows for indexing by name without incurring any runtime overhead. This permits one to implement algorithms that are oblivious to the storage order of the underlying arrays. AxisArrays can also be indexed by the values along their axes, allowing column names or interval selections.


A Julia package for efficient storage and handling of nested arrays. ArraysOfArrays provides two different types of nested arrays: ArrayOfSimilarArrays and VectorOfArrays.


ElasticArrays provides resizeable multidimensional arrays for Julia.


This Julia package handles some of the low-level details for writing cache-efficient, possibly-multithreaded code for multidimensional arrays.


A ShiftedArray is a lazy view of an Array, shifted on some or all of his indexing dimensions by some constant values.


StaticArrays provides a framework for implementing statically sized arrays in Julia, using the abstract type StaticArray{Size,T,N} <: AbstractArray{T,N}.


Implementation of arrays with metadata.


Lazy arrays and linear algebra in Julia


A block array is a partition of an array into multiple blocks or subarrays, see wikipedia for a more extensive description.


This package introduces the type StructArray which is an AbstractArray whose elements are struct (for example NamedTuples, or ComplexF64, or a custom user defined struct).


This Julia package makes it easier to index "unconventional" arrays (ones for which indexing does not necessarily start at 1), by defining constants ibegin and iend that stand for the beginning and end, respectively, of the indices range along any given dimension.


A Julia package for representing arrays with infinite dimension sizes, designed to work with other array types. Infinite arrays are by necessity lazy, and so this package is closely linked to LazyArrays.jl.


Julia package to lazily represent matrices filled with a single entry, as well as identity matrices. This package exports the following types: Eye, Fill, Ones, Zeros, Trues and Falses.


This Julia module exports a method ndgrid for generating lazy versions of grids from a collection of 1D vectors (any AbstractVector type).


Arrays with both statically and dynamically sized axes in Julia.


Array types that can use sentinel values of the element type for special values.



Fixed-width string types for facilitating certain string workflows in Julia.


This Julia package provides support for decoding and encoding texts between multiple character encodings.


This Julia package implements a new type of AbstractString, a StringView, that provides a string representation of any underlying array of bytes (any AbstractVector{UInt8}), interpreted as UTF-8 encoded Unicode data.


Natural Sort Order in Julia.


TinySegmenter.jl is a Julia version of TinySegmenter, which is an extremely compact Japanese tokenizer originally written in JavaScript by Mr. Taku Kudo.


A string type for minimizing data-transfer costs in Julia.



Geodesy is a Julia package for working with points in various world and local coordinate systems.


Simple read and write functions for ASCII raster files.


A simple Julia wrapper around the PROJ cartographic projections library.


Julia wrapper for GDAL - Geospatial Data Abstraction Library. This package is a binding to the C API of GDAL/OGR. It provides only a C style usage, where resources must be closed manually, and datasets are pointers.


Read GeoJSON files using JSON3.jl, and provide the Tables.jl interface.


Adding geospatial data to Parquet. Follows the GeoParquet v0.4 spec.


An interface for geospatial vector data in Julia.


LibGEOS is a package for manipulation and analysis of planar geometric objects, based on the libraries GEOS (the engine of PostGIS) and JTS (from which GEOS is ported).


The aim of this package is to give access to common geographics datasets.


Abstract base package for dimensional arrays and their specific traits.


This library supports reading ESRI Shapefiles in pure Julia.


This package provides polygons/multipolygons for all countries and their sub-divisions from the GADM dataset. It fetches the data dynamically from the officially hosted database using DataDeps.jl and provides a minimal wrapper API to get the coordinates of the requested geometries.


CFTime encodes and decodes time units conforming to the Climate and Forecasting (CF) netCDF conventions.


LeafletJS maps for Julia.


GeoFormatTypes defines wrapper types to make it easy to pass and dispatch on geographic formats like Well Known Text or GeoJSON between packages.


LibSpatialIndex.jl is a julia wrapper around the C API of libspatialindex, for spatially indexing kD bounding box data.


Reading and writing NetCDF files in Julia.

Data analysis


Impute.jl provides various methods for handling missing data in Vectors, Matrices and Tables.


This Julia module exports a method ndgrid for generating lazy versions of grids from a collection of 1D vectors (any AbstractVector type).


This package implements a variety of interpolation schemes for the Julia language. It has the goals of ease-of-use, broad algorithmic support, and exceptional performance.


Interpolation of scattered data in Julia.


This package performs multivariate interpolation on a rectilinear grid. At the moment, it provides implementations of multilinear and simplex interpolation.


Mamdani and Sugeno type Fuzzy Inference System in Julia.


A package for simplifying operations that involve Fourier transforms. An FFTView of an array uses periodic boundary conditions for indexing, and shifts all indices of the array downward by 1.


PaddedViews provides a simple wrapper type, PaddedView, to add "virtual" padding to any array without copying data. Edge values not specified by the array are assigned a fillvalue. Multiple arrays may be "promoted" to have common indices using the paddedviews function.


SpatioTemporalTraits serves as a relatively low-level source of spatiotemporal traits, allowing other packages the opportunity to use a common interface for their unique types.




Plots - powerful convenience for visualization in Julia.


This package provides a collection of colorschemes.


PlotThemes is a package to spice up the plots made with Plots.jl.


This package is a drop-in replacement for Plots.jl that contains many statistical recipes for concepts and types introduced in the JuliaStats organization.


Advanced Unicode plotting library designed for use in Julia's REPL.


Makie is a data visualization ecosystem for the Julia programming language, with high performance and extensibility.


The idea of this package is to create a collection of themes for Makie to customize the size and look of plot elements and colors.


MakieTeX allows you to draw and visualize arbitrary TeX documents in Makie! You can insert anything from a single line of math to a large and complex TikZ diagram.


Experimental ray tracing backend using AMDs RadeonProRender. While it's created by AMD and tailored to Radeon GPUs, it still works just as well for NVidia and Intel GPUs using OpenCL. It also works on the CPU and even has a hybrid modus to use GPUs and CPUs in tandem to render images.


Biplot recipes in 2D and 3D for Makie.jl.


A package for creating topoplots from data that were measured on arbitrarily positioned sensors.


This Package consists of two parts: a plot recipe for graphs types from Graphs.jl and some helper functions to add interactions to those plots.


A Makie recipe for plotting OpenStreetMap data. It makes heavy use of the GraphMakie package and extends it to work with the specific features of an OSMGraph.


GeoMakie.jl is a Julia package for plotting geospatial data on a given map projection.


GMT.jl is a collection of tools for manipulating geographic and Cartesian data sets (including filtering, trend fitting, gridding, projecting, etc.) and producing vector graphics illustrations ranging from simple x-y plots via contour maps to artificially illuminated surfaces and 3D perspective views.


AlgebraOfGraphics defines a language for data visualization. It is based on a few simple building blocks that can be combined using + and *.


Winston: 2D Plotting for Julia.


Gaston is a Julia package for plotting. It provides an interface to gnuplot, a mature, powerful, and actively developed plotting package available on all major platforms.


Javis.jl is a tool focused on providing an easy to use interface for making animations and developing visualizations quickly - while having fun!


This package does not interact with the Plotly web API, but rather leverages the underlying javascript library to construct plotly graphics using all local resources. This means you do not need a Plotly account or an internet connection to use this package.


Luxor is a Julia package for drawing simple static vector graphics. It provides basic drawing functions and utilities for working with shapes, polygons, clipping masks, PNG and SVG images, turtle graphics, and simple animations.


The Gnuplot.jl package allows easy and fast use of gnuplot as a data visualization tool in Julia.


Generate area-proportional Venn/Euler diagrams in Julia. This is based, in part, on algorithms from Leland Wilkinson.


This package produces corner plots, otherwise known as pair plots or scatter plot matrices: grids of 1D and 2D histograms that allow you to visualize high dimensional data.


Gadfly is a system for plotting and visualization written in Julia. It is based largely on Hadley Wickhams's ggplot2 for R and Leland Wilkinson's book The Grammar of Graphics.


Compose is a declarative vector graphics system written in Julia. It's designed to simplify the creation of complex graphics and serves as the basis of the Gadfly data visualization package.


This module provides a Julia interface to the Matplotlib plotting library from Python, and specifically to the matplotlib.pyplot module.


Cloudy Mountain Plot in Julia. An informative RDI categorical distribution plot inspired by Violin, Bean and Pirate Plots. (RDI = Raw data + Descriptive statistics + Inferential statistics)



The goal of Graphs.jl is to offer a performant platform for network and graph analysis in Julia, following the example of libraries such as NetworkX in Python.


GraphRecipes is a collection of recipes for visualizing graphs. Users specify a graph through an adjacency matrix, an adjacency list, or an AbstractGraph via Graphs. GraphRecipes will then use a layout algorithm to produce a visualization of the graph that the user passed.


Layout algorithms for graphs and trees in pure Julia.


Edge-Weighted Graphs for Graphs.jl.


This package consists of a collection of network algorithms. In short, the major difference between MatrixNetworks.jl and packages like LightGraphs.jl or Graphs.jl is the way graphs are treated.


MultilayerGraphs.jl is a Julia package for the construction, manipulation and analysis of multilayer graphs extending Graphs.jl.


Graph layout and visualization algorithms based on Compose.jl and inspired by GraphLayout.jl.


MetaGraphs.jl graphs with arbitrary metadata.


GraphIO provides support to Graphs.jl for reading/writing graphs in various formats.


Memory-efficient, performant graph structures optimized for large networks.


This package provides an interface to the the GraphViz package for graph visualization.


Flow algorithms on top of Graphs.jl, including maximum_flow, multiroute_flow and mincost_flow.


Tools for interoperability between DataFrame objects and LightGraphs and MetaGraphs objects.


Implements community detection for Graphs.jl. Both Nonbacktracking and Bethe Hessian detection are supported.


Matching algorithms on top of Graphs.jl.


Extra functionality for Graphs.jl.


LightGraphs offers both (a) a set of simple, concrete graph implementations -- Graph (for undirected graphs) and DiGraph (for directed graphs), and (b) an API for the development of more sophisticated graph implementations under the AbstractGraph type.


Extra functionality for Graphs.


VegaGraphs implements graph visualization with Vega-Lite.


Encoding special graph structures in types.



This is a small package to make it easier to type LaTeX equations in string literals in the Julia language, written by Steven G. Johnson.


This is a work in progress package aimed at providing a pure Julia engine for LaTeX math mode. It is composed of two main parts: a LaTeX parser and a LaTeX engine, both only for LaTeX math mode.


This library allows one to create Tikz pictures and save in various formats. It integrates with IJulia, outputting SVG images to the notebook.


This is a small package to visualize a graph corresponding to an abstract syntax tree (AST) of a Julia expression. It uses the TikzGraphs.jl package to do the visualization.


This library uses the LaTeX package pgfplots to produce plots. It integrates with IJulia, outputting SVG images to the notebook.


This library generates graph layouts using the TikZ graph layout package.


A wrapper around TikzPictures.jl for easier drawing of commutative diagrams using tikz-cd.


Parsing BibTeX files for the Julia language.



JuMP is a domain-specific modeling language for mathematical optimization embedded in Julia.


The Calculus package provides tools for working with the basic calculus operations of differentiation and integration. You can use the Calculus package to produce approximate derivatives by several forms of finite differencing or to produce exact derivative using symbolic differentiation. You can also compute definite integrals by different numerical methods.


This package provides support for one-dimensional numerical integration in Julia using adaptive Gauss-Kronrod quadrature.


A combinatorics library for Julia, focusing mostly (as of now) on enumerative combinatorics and permutations. As overflows are expected even for low values, most of the functions always return BigInt, and are marked as such below.


This package implements a variety of data structures.


This Julia package extends the LinearAlgebra library with support for special matrices that are used in linear algebra.


Fast matrix multiplication and division for Toeplitz, Hankel and circulant matrices in Julia.


Blocked Sparse Matrices in Julia.


A Julia package for working with special matrix types.


Nemo is a computer algebra package for the Julia programming language.


FastTransforms.jl allows the user to conveniently work with orthogonal polynomials with degrees well into the millions.


Implementations of basic math functions which return NaN instead of throwing a DomainError.


Polynomials.jl is a Julia package that provides basic arithmetic, integration, differentiation, evaluation, and root finding for univariate polynomials.


Julia package for the Non-equidistant Fast Fourier Transform


The nonequispaced fast Fourier transform or NFFT, see [Keiner, Kunis, Potts, 2006] and [Plonka, Potts, Steidl, Tasche, 2018], overcomes one of the main shortcomings of the FFT - the need for an equispaced sampling grid.


Measurements.jl relieves you from the hassle of propagating uncertainties coming from physical measurements, when performing mathematical operations involving them. The linear error propagation theory is employed to propagate the errors.


A package for performing Singular Spectrum Analysis (SSA).


Symbolics.jl is a fast and modern Computer Algebra System (CAS) for a fast and modern programming language (Julia). The goal is to have a high-performance and parallelized symbolic algebra system that is directly extendable in the same language as the users.


This is a suite for numerically solving differential equations written in Julia and available for use in Julia, Python, and R.


The HCubature module is a pure-Julia implementation of multidimensional "h-adaptive" integration. That is, given an n-dimensional integral


Solving non-linear systems of equations in Julia.


Roots is a Julia package for finding zeros of continuous scalar functions of a single real variable.


This small package contains the functions rref and rref!.


Julia extensions to provide high performance computational support.


Julia implementation of the real cubic root finding method described in:


A package to find isolating intervals for the real roots of a square free polynomial.


A simple library that contains implementations of the irreducible root systems.


Package that implements some root finding methods in Julia.


A Julia package for finding roots of a continuous function when the approximate distribution of the roots is known.


A simple GPU-capable root solver package.


A light-weight collection of simple root-finding algorithms.


Global complex Roots and Poles Finding in Julia.


This package is a Julia wrapper of the Fortran programs accompanying Fast and Backward Stable Computation of Roots of Polynomials by Jared L. Aurentz, Thomas Mach, Raf Vandebril and David S. Watkins.


This package provides a data type RationalRoot{T<:Integer} to exactly represent the (positive or negative) square root of a rational number of type Rational{T}.


PolynomialRoots.jl is a library for finding roots of complex univariate polynomials, written in Julia.


This package provides a set of geometric primitive types (balls, cuboids, cylinders, and so on) and operations on them designed to enable piecewise definition of functions, especially for finite-difference and finite-element simulations, in the Julia language.


Fast multidimensional Chebyshev interpolation on a hypercube (Cartesian-product) domain, using a separable (tensor-product) grid of Chebyshev interpolation points, as well as Chebyshev regression (least-square fits) from an arbitrary set of points. In both cases we support arbitrary dimensionality, complex and vector-valued functions, and fast derivative and Jacobian computation.


This module provides a free Julia-language Sobol low-discrepancy-sequence (LDS) implementation. This generates "quasi-random" sequences of points in N dimensions which are equally distributed over an N-dimensional hypercube.


Simpson.jl is a Julia package to integrate y(x) using samples and the composite Simpson's rule.


Ferrite is a finite element toolbox that provides functionalities to implement finite element analysis in Julia. The aim is to be general and to keep mathematical abstractions.


CALFEM.jl is an API port of the simple Matlab FE toolbox CALFEM written in Julia. The purpose of this package is to ease the transition for people who want to try out Julia for FE-analysis. CALFEM.jl is built on top of Ferrite.

Artificial Intelligence


A Machine Learning Framework for Julia.


This package makes a distinction between machine type and scientific type of a Julia object.


Flux is a library for machine learning geared towards high-performance production pipelines.


Knet (pronounced "kay-net") is the Koç University deep learning framework implemented in Julia by Deniz Yuret and collaborators.


FastAI.jl is inspired by fastai, and is a repository of best practices for deep learning in Julia.


ModelingToolkit.jl is a modeling language for high-performance symbolic-numeric computation in scientific computing and scientific machine learning.


Global Sensitivity Analysis (GSA) methods are used to quantify the uncertainty in output of a model with respect to the parameters.


A pure Julia implementation of Decision Tree Algorithms for Regression.


NearestNeighbors.jl is a package written in Julia to perform high performance nearest neighbor searches in arbitrarily high dimensions.

Signal analysis


This package is mainly not intended to be used directly. Instead, developers of packages that implement FFTs (such as FFTW.jl or FastTransforms.jl) extend the types/functions defined in AbstractFFTs.


This package extends the functionality provided by AbstractFFTs


DSP.jl provides a number of common digital signal processing routines in Julia.


Deconvolution.jl provides a set of functions to deconvolve digital signals, like images or time series.


A Julia package for fast wavelet transforms (1-D, 2-D, 3-D, by filtering or lifting). The package includes discrete wavelet transforms, column-wise discrete wavelet transforms, and wavelet packet transforms.


This package is an offshoot of Wavelets.jl for the continuous wavelets.


This package is a Julia extension package to Wavelets.jl (WaveletsExt is short for Wavelets Extension).


A julialang package for DSP related estimation.


A package to compute Mel Frequency Cepstral Coefficients.


Finding peaks in a 1-D signal in Julia. The implementation is based on find_peaks in SciPy.


A simple package for interpolating 1D data with Akima cubic splines, based on "A New Method of Interpolation and Smooth Curve Fitting Based on Local Parameters", Akima, 1970.


EntropyHub: An open-source toolkit for entropic time series analysis.


This module computes the modified discrete cosine transform (MDCT) in the Julia language and the inverse transform (IMDCT), using the fast type-IV discrete cosine tranform (DCT-IV) functions in the FFTW.jl package.



This is a convenience meta-package which allows loading essential packages for statistics.


Bootstrap.jl: Statistical Bootstrapping


The package provides the CategoricalArray type designed to hold categorical data (either unordered/nominal or ordered/ordinal) efficiently and conveniently.


Clustering.jl is a Julia package for data clustering.


A Julia package for evaluating distances(metrics) between vectors.


This package implements several hypothesis tests in Julia.


Kernel density estimators for Julia.


This is a pure Julia loess implementation, based on the fast kd-tree based approximation, implemented in the netlib loess C/Fortran code, and used by many, including in R's loess function.


A Julia package for multivariate statistics and data analysis (e.g. dimensionality reduction).


MixedModels.jl is a Julia package providing capabilities for fitting and examining linear and generalized linear mixed-effect models.


StatsBase.jl is a Julia package that provides basic support for statistics. Particularly, it implements a variety of statistics-related functions, such as scalar statistics, high-order moment computation, counting, ranking, covariances, sampling, and empirical density estimation.


This package provides common abstractions and utilities for specifying, fitting, and evaluating statistical models.


Mathematical functions related to statistics.


Linear and generalized linear models in Julia.


The Distributions package provides a large collection of probabilistic distributions and related functions.


The TimeSeries package provides convenient methods for working with time series data in Julia.


MultivariateStats.jl is a Julia package for multivariate statistical analysis. It provides a rich set of useful analysis techniques, such as PCA, CCA, LDA, PLS, etc.


Discreet is a small opinionated toolbox to estimate entropy and mutual information from discrete samples. It contains methods to adjust results and correct over- or under-estimations.


Entropy and mutual information.


Lasso.jl is a pure Julia implementation of the glmnet coordinate descent algorithm for fitting linear and generalized linear Lasso and Elastic Net models.


The MultipleTesting package offers common algorithms for p-value adjustment and combination as well as the estimation of the proportion π₀ of true null hypotheses.


A Julia package to support conjugate prior distributions.


PGM.jl is a Julia framework for probabilistic graphical models.


QuantEcon.jl is a Julia package for doing quantitative economics.


This package allows computing one- or multi-way frequency tables (a.k.a. contingency or pivot tables) from any type of vector or array.


OnlineStats does statistics and data visualization for big/streaming data via online algorithms. Each algorithm: 1) processes data one observation at a time. 2) uses O(1) memory.


This Julia package provides a collection of predictors and loss functions, mainly to support the implementation of (regularized) empirical risk minimization methods.


This package is based on EmpiricalRisks, and provides a set of algorithms to perform regression analysis. This package supports all regression problems that can be formulated as regularized empirical risk minimization.

Image processing


JuliaImages is a collection of packages specifically focused on image processing.


An image display GUI for Julia.


When visualizing images, it is not uncommon to provide a 2D view of different image sources. For example, comparing multiple images of different sizes, getting a preview of machine learning dataset. This package aims to provide easy-to-use tools for such tasks.


FileIO.jl integration for image files.


This package provides support for image resizing, image rotation, and other spatial transformations of arrays.


ImageFiltering supports linear and nonlinear filtering operations on arrays, with an emphasis on the kinds of operations used in image processing.


A Julia package containing a number of algorithms for analyzing images and automatically binarizing them into background and foreground.


A Julia package for analyzing a one-dimensional histogram and automatically choosing a threshold which partitions the histogram into two parts.


A Julia package for enhancing and manipulating image contrast.


ImageDistances.jl aims to: follow the same API in Distances.jl, support image types, provide image-specific distances.


Image Segmentation is the process of partitioning the image into regions that have similar attributes.


Image inpainting algorithms in Julia.


ImageQualityIndexes provides the basic image quality assessment methods. Check the reasoning behind the code design here if you're interested in.


ImageFeatures is a package for identifying and characterizing "keypoints" (salient features) in images.


This package provides morphology operations for structure analysis and image processing.


ImageMetadata is a simple package providing utilities for working with images that have metadata attached.


A drawing package for JuliaImages.


This is a work-in-progress Julia package to provide Julia-callable wrappers to the libjpeg-turbo C library.



Julia for handling BDF+ and EDF+ EEG and similar signal data files.


Process EEG files in Julia.


Miscellaneous Julia utilities for psychophysics research.



Process neuroimaging data using the Julia language.


Read NIRX functional near-infrared spectroscopy files in Julia.


BDF.jl is a Julia module to read/write BIOSEMI 24-bit BDF files (used for storing electroencephalographic recordings).


Read and write European Data Format (EDF/EDF+) and BioSemi Data Format (BDF) files in Julia.


Julia for handling BDF+ and EDF+ EEG and similar signal data files.


Generate auditory stimuli for real-time applications. Specifically, stimuli that are used in auditory research.


EEG/MEG/NIRS/NIBS analysis with Julia.


Toolbox to perform linear regression on biological signals.


UnfoldMakie allows many visualizations for ERP and "Unfolded"-models. Building on the Unfold and Makie, it grants users highly customizable plots.

Misc packages


SeisNoise.jl provides routines for quickly and efficiently implementing seismic interferometry.


This package provides some basic utilities for working with hexagonal grids.


A port of the Processing language ( to Julia.


An extensible framework for high-performance geostatistics in Julia.


Term.jl is a Julia library for producing styled, beautiful terminal output.


Full support for ANSI colored strings in Julia. Allows formatted output in REPL/Shell environment for both Unix and Mac.


IOIndents facilitates writing indented and aligned text to buffers (like files or the terminal).


Crayons is a package that makes it simple to write strings in different colors and styles to terminals. It supports the 16 system colors, both the 256 color and 24 bit true color extensions, and the different text styles available to terminals. The package is designed to perform well, have no dependencies and load fast (about 10 ms load time after precompilation).


The Preferences package provides a convenient, integrated way for packages to store configuration switches to persistent TOML files, and use those pieces of information at both run time and compile time in Julia v1.6+.


Weave is a scientific report generator/literate programming tool for Julia. It resembles Pweave, knitr, R Markdown, and Sweave.


An omnibus package with a high level API for controlling peripherals on the Raspberry Pi computer. Currently has support for the GPIO pins on the Pi, and the ExplorerHat.


Control GPIO pins on the Raspberry Pi from Julia.


Implementation of some data structures and algorithms from the Chalmers courses DAT038 and TIN093 in Julia as en exercise and for fun.


This repository only serves an educational purpose. It implements a large number of data structures and algorithms from the similarly named book by Clifford A. Schaffer.


This package collects useful filesystem datastructures. Currently, it implements two file caches: SizeConstrainedFileCache and NFileCache.


Possibly faster alternatives to the priority queue from DataStructures.jl. See the documentation for details.


This is a Julia script for analysing light intensities as a function of time and space in time-lapse image stacks of seedling roots.


ConstLab.jl is a small package for Julia to test and experiment with constitutive models. It's main functionality is to call a user given material routine over a time range, aggregate the material response and return it back for analysis. The load applied to the material can be user generated or one of the predefined load cases can be used. To facilitate visualizing the results, some auxiliary plot functions are provided.



Bakshi T. Tanmay Teaches Julia for Beginners: A Springboard to Machine Learning for All Ages.: 9781260456639

Balbaert I. Getting Started with Julia. ISBN: 9781783284795

Balbaert I. Julia 1.0 Programming - Second Edition. ISBN: 9781788999090

Balbaert I, Salceanu A. Julia 1.0 programming complete reference guide: discover Julia, a high-performance language for technical computing. ISBN: 9781838822248

Dash S. Hands-on Julia Programming. ISBN: 9789391030919

Engheim E. Julia as a Second Language. ISBN: 1617299715

Engheim E. Julia for Beginners.

Joshi A, Lakhanpal R. Learning Julia. ISBN: 9781785883279

Kalicharan N. Julia - Bit by Bit. ISBN: 9783030739362

Kalicharan N. Julia - Bit by Bit: Programming for Beginners (Undergraduate Topics in Computer Science) ISBN: 303073935X

Kamiński B, Szufel P. Julia 1.0 Programming Cookbook. ISBN: 9781788998369

Kerns G. Introduction to Julia.

Kwon C. Julia Programming for Operations Research.

Kwong T. Hands-on design patterns and best practices with Julia: proven solutions to common problems in software design for Julia 1.x. ISBN: 9781838648817

Lauwens B. Think Julia: How to Think Like a Computer Scientist. ISBN: 9781484251898

Lobianco A. Julia Quick Syntax Reference: A Pocket Guide for Data Science Programming. ISBN: 9781484251904

Nagar S. Beginning Julia Programming. ISBN: 9781484231708

Rohit JR. Julia Cookbook: over 40 recipes to get you up and running with programming using Julia. ISBN: 9781785882012

Salceanu A. Julia Programming Projects. ISBN: 9781788292740

Sengupta A, Sherrington M, Balbaert I. Julia: High Performance Programming 2E. ISBN: 9781788298117

Sengupta A, Sherrington M, Balbaert I. Julia: High Performance Programming. ISBN: 9781787125704

Sengupta A. Julia High Performance. ISBN: 9781785880919

Sengupta A. Julia high performance: design and develop high performing programs with Julia. ISBN: 9781785880919

Sengupta A. The Little Book of Julia Algorithms: A workbook to develop fluency in Julia programming. ISBN: 9781838173609

Sherrington M. Mastering Julia: develop your analytical and programming skills further in Julia to solve complex data processing problems. ISBN: 9781783553310

Zea DJ. Interactive Visualization and Plotting with Julia: Create impressive data visualizations through Julia packages. ISBN: 1801810516

Data science

Numerical methods for Scientifc Computing. ISBN: 9798985421804

Adams C. Learning Microeconometrics with R. ISBN: 9780367255381

Boyd S, Vandenberghe S. Introduction to Applied Linear Algebra – Vectors, Matrices, and Least Squares. ISBN: 9781316518960

Chan S. Introduction to Probability for Data Science. ISBN: 978-1-60785-747-1

Joshi A. Julia for data science: explore the world of data science from scratch with Julia by your side. ISBN: 9781785289699

Kamiński B, Prałat P. Train Your Brain - Challenging Yet Elementary Mathematics. ISBN: 9780367564872

Kamiński B. Julia for Data Analysis. ISBN: 1633439364

Kamiński B. Julia for Data Analysis. ISBN: 9781633439368

Kochenderfer M, Wheeler T, Wray K. Algorithms for Decision Making. ISBN: 9780262047012

Kochenderfer M, Wheeler T. Algorithms for Optimization. ISBN: 9780262039420

McNicholas P, Tait P. Data science with Julia. ISBN: 9781351013673

Orban D, Arioli M. Iterative Solution of Symmetric Quasi-Definite Linear Systems. DOI: 10.1137/1.9781611974737

Storopoli J, Huijzer R, Alonso L. Julia data science. ISBN: 9798489859165

Voulgaris Z. Julia for Data Science.


Nazarathy Y, Klok H. Statistics with Julia: Fundamentals for Data Science, Machine Learning and Artificial Intelligence (Springer Series in the Data Sciences). ISBN: 3030709000

Artificial intelligence

Voulgaris Z. Julia for Machine Learning. ISBN: 9781634628136

Signal analysis

Image processing

Cudihins D. Hands-On Computer Vision with Julia. ISBN: 9781788998796


Quantitative Economics with Julia

This website presents a set of lectures on quantitative economic modeling, designed and written by Jesse Perla, Thomas J. Sargent and John Stachurski. The language instruction is Julia.


A collection of explanations and tips to make the best use of Julia. Many answers are extracts from solutions provided to user questions in the Julia Discourse.

Novak K. Numerical Methods for Scientific Computing ISBN: 9798985421804

The book covers the mathematical theory and practical considerations of the essential numerical methods used in scientific computing. Julia is used throughout, with Python and Matlab/Octave included in the back matter. Jupyter notebooks of the code are available on GitHub.

Using Julia on the HPC


Julia language: a concise tutorial

Exploratory PCA in Julia

Julia macros for beginners

A really brief introduction to audio signal processing in Julia

Julia: delete rows and columns from an array or matrix

Nybo Nissen J. What scientists must know about hardware to write fast code

The aim of this tutorial is to give non-professional programmers a brief overview of the features of modern hardware that you must understand in order to write fast code.


JuliaBerry is an organisation that brings together various resources for using the Julia language for the Raspberry Pi.

Beautiful Makie

A gallery of easy to copy-paste examples.

Julia Tutorials Template

A template for building websites with Julia. Easily publish Pluto notebooks online.

Julia by Example