Adam Wysokiński
5519ebca86

18 hours ago  

MPJ.md  1 month ago  
README.md  18 hours ago 
README.md
Big Book of Julia
Welcome
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
Licence
This content is free to use and is licensed under the Creative Commons AttributionNonCommercialNoDerivs 3.0 License.
Language documentation
This is the official Julia documentation.
Videos
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
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
Packages
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 packagespecific 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 RPMmd 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 crossplatform alternative. It can also be used without administrator rights, in contrast to the current Linuxbased 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 archspecjson
, 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 builtin sampling profiler.
FileIO aims to provide a common framework for detecting file formats and dispatching to appropriate readers/writers.
Julia is, in general, a "justbarelyaheadoftime" 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 Julialanguage backend combined with the Jupyter interactive environment (also used by IPython).
This package is a collection of webbased 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 easytouse arrays down to handwritten kernels using lowlevel 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 commandline 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.jlcompatible 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 righthand expression, it will be replaced with the result of the lefthand 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 3rdparty 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 generalpurpose probabilistic programming system with programmable inference, embedded in Julia
Soss is a library for probabilistic programming.
[Tilde.jl]ttps://github.com/cscherrer/Tilde.jl)
WIP, successor to Soss.jl.
This package automates building of userspecific system images (sysimages) for the specific project.
NBInclude is a package for the Julia language which allows you to include and execute IJulia (Julialanguage 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 commandline 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.
Interoperability
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 crossplatform 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 integerbased indexing is automatically converted from Python's 0based indexing to Julia's 1based 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.
IO
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.
Data
CSV.jl is a pureJulia package for handling delimited text data, be it commadelimited (csv), tabdelimited (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 datatransfer costs in Julia.
DataCubes provides a framework to handle multidimensional tables.
This package has the purpose to print data in matrices in a humanreadable format. It was inspired in the functionality provided by ASCII Table Generator.
A collection of type parsers and utilities for Julia.
Simple, fast, columnbased 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.jlcompatible 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 datarelated 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 ORMlike 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 memorymapping.
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 featherformatted 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.
Arrays
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 Julialanguage 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" inplace elementwise transformations of arrays for the Julia programming language.
UnsafeArrays provides stackallocated pointerbased 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 lowlevel details for writing cacheefficient, possiblymultithreaded 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.
Strings
Fixedwidth 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 UTF8 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 datatransfer costs in Julia.
Geospatial
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 subdivisions 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 easeofuse, 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 lowlevel source of spatiotemporal traits, allowing other packages the opportunity to use a common interface for their unique types.
Graphics
Plots
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 dropin 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 xy 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 areaproportional 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)
Graphs
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.
EdgeWeighted 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.
Memoryefficient, 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 VegaLite.
Encoding special graph structures in types.
TeX
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 tikzcd
.
Parsing BibTeX files for the Julia language.
Mathematics
JuMP is a domainspecific 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 onedimensional numerical integration in Julia using adaptive GaussKronrod 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 Nonequidistant 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 highperformance 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 pureJulia implementation of multidimensional "hadaptive" integration. That is, given an ndimensional integral
Solving nonlinear 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: https://www.jstor.org/stable/27821778.
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 GPUcapable root solver package.
A lightweight collection of simple rootfinding 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 finitedifference and finiteelement simulations, in the Julia language.
Fast multidimensional Chebyshev interpolation on a hypercube (Cartesianproduct) domain, using a separable (tensorproduct) grid of Chebyshev interpolation points, as well as Chebyshev regression (leastsquare fits) from an arbitrary set of points. In both cases we support arbitrary dimensionality, complex and vectorvalued functions, and fast derivative and Jacobian computation.
This module provides a free Julialanguage Sobol lowdiscrepancysequence (LDS) implementation. This generates "quasirandom" sequences of points in N dimensions which are equally distributed over an Ndimensional 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 FEanalysis. 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 highperformance production pipelines.
Knet (pronounced "kaynet") 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 highperformance symbolicnumeric 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 (1D, 2D, 3D, by filtering or lifting). The package includes discrete wavelet transforms, columnwise 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 1D 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 opensource 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 typeIV discrete cosine tranform (DCTIV) functions in the FFTW.jl package.
Statistics
This is a convenience metapackage 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 kdtree 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 mixedeffect models.
StatsBase.jl is a Julia package that provides basic support for statistics. Particularly, it implements a variety of statisticsrelated functions, such as scalar statistics, highorder 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 underestimations.
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 pvalue 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 multiway 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 easytouse 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 onedimensional 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 imagespecific 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 workinprogress Julia package to provide Juliacallable wrappers to the libjpegturbo C library.
Neuroscience
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 nearinfrared spectroscopy files in Julia.
BDF.jl is a Julia module to read/write BIOSEMI 24bit 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 realtime 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 (https://www.processing.org) to Julia.
An extensible framework for highperformance 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 timelapse 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.
Books
JuliaProgramming
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 highperformance language for technical computing. ISBN: 9781838822248
Dash S. Handson 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. Handson 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: 9781607857471
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 QuasiDefinite Linear Systems. DOI: 10.1137/1.9781611974737
Storopoli J, Huijzer R, Alonso L. Julia data science. ISBN: 9798489859165
Voulgaris Z. Julia for Data Science.
Statistics
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. HandsOn Computer Vision with Julia. ISBN: 9781788998796
Misc
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.
Tutorials
Julia language: a concise tutorial
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 nonprofessional 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.
A gallery of easy to copypaste examples.
A template for building websites with Julia. Easily publish Pluto notebooks online.