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

Its objective is to be a set of resources for Julia programmers, data scientists and researchers. It contains links to tutorials, courses, blogs, videos, package documentation and books related to Julia programming.

BBJ repository is located at: https://codeberg.org/AdamWysokinski/BBJ.

If you'd like to show your appreciation with a donation you're most welcome to do so here.

This content is free to use and is licensed under the CC BY-NC-ND 3.0 License (Creative Commons Attribution-NonCommercial-NoDerivs 3.0).

Last update 11 September, 2024

Number of entries 1432

Created and maintained by Adam Wysokiński.

If you've contributed, add your name below:

Adam Wysokiński, jluis, uncomfyhalomacro, heltonmc

- Welcome to the Big Book of Julia!
- Contributors
- Table of content
- Language documentation
- Videos
- Julia Academy Courses
- Blogs / Forums
- Packages
- Julia programming
- Parallel computing
- Interoperability
- Import/Export
- Databases
- Data types: Tables
- Data types: Numbers
- Data types: Arrays
- Data types: Strings
- Data types: Structures
- Data types: Time series
- Data analysis
- Graphics: Graphics
- Graphics: GUI
- Graphics: Plots
- Graphics: Graphs
- Graphics: TeX
- Mathematics
- Artificial intelligence
- Signal analysis
- Image processing and analysis
- Statistics
- Neuroscience
- Web technologies
- Networking
- Audio
- Geospatial
- Quantum Computing
- Dates and Time
- GPU
- Misc packages

- Books
- Misc
- Tutorials

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

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

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

Intro to Julia tutorial (version 1.0)

Julia Journey: Juggling Jargons Joyfully

Searchable list of all registered Julia 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.

PkgTemplates creates new Julia packages in an easy, repeatable, and customizable way.

PkgEval.jl is a package to test one or more Julia versions against the Julia package ecosystem, and is used by Nanosoldier.jl for keeping track of package compatibility of upcoming Julia versions.

This package contains the infrastructure powering the @nanosoldier CI bot used by the Julia language.

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.

Utility package for checking if a new version of a Julia package is available. It uses the current `Project.toml`

file and a special `CHANGELOG.html`

file to determine the latest versions.

Provides the `@autodocs`

macro, which, if invoked at the start of a module declaration, will generate basic documentation for all declared Julia objects (functions, structs, macros, etc.) in that module. If an object already has documentation, it will be expanded (but not overwritten).

This "package" is a prototype for various operations needed for a next-generation package cache in Julia, targeted to be merged in the Julia 1.9 and/or 1.10 timeframe.

This package provides insight about what's stored in Julia's package precompile files. This works only on Julia 1.9 and above, as it targets the new pkgimage format.

BenchmarkTools makes performance tracking of Julia code easy by supplying a framework for writing and running groups of benchmarks as well as comparing benchmark results.

This package is a collection of Julia benchmarks used to track the performance of the Julia language.

PkgBenchmark provides an interface for Julia package developers to track performance changes of their packages.

Take Julia code coverage and memory allocation results, do useful things with them.

CoverageTools.jl provides the core functionality for processing code coverage and memory allocation results.

A package for measuring the internal test coverage of the Julia programming language.

This is a collection of trivial functions to facilitate generating and exploring test coverage information for Julia packages locally, without using any remote/cloud services.

Repository for testing Julia support at the Travis Continuous Integration (CI) service.

This contains a "universal" Appveyor script for Julia repositories, making it easier to set up matrix builds and keep URLs up-to-date.

Log analysis pipeline for CI errors.

This package is intended to make managing a shared depot used by multiple workers easier. It was designed for running Yggdrasil, where many large artifacts are downloaded by individual agents on a single machine, each agent writes to its own depot, but many artifacts are duplicated across each agent depot. This package allows for transparent "compaction" of depots by inspecting resoures contained within depots and moving shared resources into a shared, read-only depot stored higher on the `DEPOT_PATH`

by each agent.

This is a collection of utility functions when running Julia jobs on Buildkite.

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+.

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.

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.

PrecompileTools allows you to reduce the latency of the first execution of Julia code. It is applicable for package developers and for "ordinary users" in their personal workflows.

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).

Revise.jl allows you to modify code and use the changes without restarting Julia. With Revise, you can be in the middle of a session and then update packages, switch git branches, and/or edit the source code in the editor of your choice; any changes will typically be incorporated into the very next command you issue from the REPL. This can save you the overhead of restarting Julia, loading packages, and waiting for code to JIT-compile.

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

This package contains utilities for setting up documentation generation with Documenter.jl.

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

A Documenter plugin package that enables native support for mermaid.js diagrams in Documenter documents (in HTML builds only).

Serve docs generated by Documenter.

Extensions for Julia's docsystem.

Generate documentation for all the packages.

Provides the `IOCapture.capture(f)`

function which evaluates the function `f`

, captures the standard output and standard error, and returns it as a string, together with the return value.

A source code highlighter for Julia.

ANSIColoredPrinters convert a text qualified by ANSI escape codes to another format.

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!

Git REPL mode for Julia.

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.

This is a library providing basic SIMD support in Julia.

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.

[Tilde.jl]ttps://github.com/cscherrer/Tilde.jl)

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.

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.

Rewrite.jl is an efficient symbolic term rewriting engine.

This package provides a repl mode for the Julia term rewriting system Rewrite.jl.

Julia's multiple dispatch offers a lot of expressive power which is a strict superset of things like currying in Haskell. However, sometimes it's convenient to have currying and one doesn't want to write out the methods themselves.

SpecializeVarargs.jl does one thing: force to julia to create and specialize on a given number of varadic arguments. This is likely only useful to people doing very complicated codegen in high performance situations, e.g. in Cassette overdub methods like those used in ForwardDiff2.jl.

ExprTools provides tooling for working with Julia expressions during metaprogramming. This package aims to provide light-weight performant tooling without requiring additional package dependencies.

MacroTools provides a library of tools for working with Julia code and expressions. This includes a powerful template-matching system and code-walking tools that let you do deep transformations of code in a few lines.

Julia infix function hack, based on this Python hack: http://code.activestate.com/recipes/384122-infix-operators

Spec.jl is an experimental package trying to incorportate ideas from Clojure's spec. The idea in Spec.jl is that we define `@pre_spec`

and/or `@post_spec`

functions which are run before and/or after a given function when in a validation context.

BootlegCassette.jl is a quick and dirty package that tries to mimic the interface of Cassette.jl using IRTools.jl under the hood. This isn't a great implementation, but provided you do not use tagging and only use `@context`

, `ovderdub`

, `prehook`

, `posthook`

and `recurse`

, BootlegCassette.jl should work as a drop-in replacement for Cassette.jl.

Legible Lambdas for Julia.

This small package provides an alternative syntax for writing anonymous functions. It allows the use of three types of function arguments within the body of a call to `@λ`

or `@lf`

.

Underscores provides a macro `@_`

for passing closures to functions by interpreting `_`

placeholders as anonymous function arguments. For example `@_ map(_+1, xs)`

means `map(x->x+1, xs)`

.

Lazy.jl provides Julia with the cornerstones of functional programming - lazily-evaluated lists and a large library of functions for working with them.

Assertions that can be turned on or off with a switch, with no runtime penalty when they're off.

This package reexports Unitful.jl alongside two extra functions: 1) `natural`

, a function for converting a given quantity to the Physicist's so-called "natural units", 2) `unnatural`

, a function for converting from natural units to a given unnatural unit such as meters.

A StaticModule is basically a little, statically sized and typed namespace you can use for enclosing Julia code and variables without runtime overhead and useable in either the global or local scopes. StaticModules are not a replacement modules, but may be complementary.

The idea behind ReplMaker.jl is to make a tool for building (domain specific) languages in Julia.

Gaius.jl is a multi-threaded BLAS-like library using a divide-and-conquer strategy to parallelism, and built on top of the fantastic LoopVectorization.jl. Gaius spawns threads using Julia's depth first parallel task runtime and so Gaius's routines may be fearlessly nested inside multi-threaded Julia programs.

The goal of this library is to allow for a simplified style of writing `@generated`

functions, inspired by zig comptime features.

Bumper.jl is an experimental package that aims to make working with bump allocators easy and safer (when used right). You can dynamically allocate memory to these bump allocators, and reset them at the end of a code block, just like Julia’s default stack. Allocating to the a `AllocBuffer`

with Bumper.jl can be just as efficient as stack allocation.

A Julia port of Rhea, an improved C++ implementation of the Cassowary constraint solver.

FilteredGroupbyMacro.jl offers a macro `@by`

with which a concise syntax for filtered split-apply-combine operations can be expressed concisely. It is very similar in nature to the `[i,j,by]`

indexing that the well-known package data.table in the R ecosystem uses.

ClearStacktrace.jl is an experimental package that replaces `Base.show_backtrace`

with a clearer version that uses alignment and colors to reduce visual clutter and indicate module boundaries, and expands base paths so they are clickable.

Observables are like Refs but you can listen to changes.

A different take on the Observables idea, where listeners and inputs are linked both ways to avoid observable hell.

This package offers a simplified syntax to create documents for use with Weave.jl.

A package to run benchmarks of different versions, branches, or commits of packages against each other on multiple Julia versions.

A Julia package for piping a value through a series of transformation expressions using a more convenient syntax than Julia's native piping functionality.

A package for people who don't want to learn or read regexes. ReadableRegex.jl gives you a syntax that is much easier to write and understand than the rather cryptic standard Regex. The syntax is as close as possible to a natural language description of the Regex. Especially for nested and grouped expressions with special characters it is orders of magnitudes easier to understand than a simple regex string. You can also compile the function expression before using it with the @compile macro for lower runtime costs.

HotTest.jl is an experimental package which works in conjunction with Julia's default testing pipeline in Pkg.jl. The tests are run in a sandbox module in the current session, this means that compilation delays only matter for the first run, but each run is still independent from session state. Rerunning the tests afterwards should be quick.

This package implements the Microsoft Language Server Protocol for the Julia programming language.

SymbolServer is a helper package for LanguageServer.jl that provides information about internal and exported variables of packages (without loading them). A package's symbol information is initially loaded in an external process but then stored on disc for (quick loading) future use.

Width-sensitive formatter for Julia code. Inspired by gofmt, refmt, and black.

Static Code Analysis for Julia.

A parser for Julia using Tokenize that aims to extend the built-in parser by providing additional meta information along with the resultant AST.

Julia implementation of the Debug Adapter Protocol.

This package exports Julia profile information into Chrome .cpuprofile files.

This package runs `@testitem`

tests.

This package provides the `@testitem`

macro for the test runner feature in VS Code. Please look at https://github.com/julia-vscode/TestItemRunner.jl for the documentation for this package here.

This package provides low level features that are used by TestItemRunner.jl and LanguageServer.jl.

Letting you know your tests are making progress, by printing a green dot • every time a test passes, and announcing when a `@testset`

is finished.

An implementation for JSON RPC 2.0. See the specification for details. Currently, only JSON RPC 2.0 is supported. This package can act as both a client & a server.

A `DeferredFuture`

is like a regular Julia `Future`

, but is initialized when put! is called on it. This means that the data in the `DeferredFuture`

lives with the process the data was created on. The process the `DeferredFuture`

itself lives on never needs to fetch the data to its process. This is useful when there is a lightweight controller process which handles scheduling work on and transferring data between multiple machines.

Julia syslog interface.

Trace provides a minimal interface for zero overhead program tracing in Julia.

A simple read-write lock for Julia.

Definitions of the Julia types for simulating an ISO's market clearing.

Checkpoints.jl allows packages to `register`

checkpoints which can serialize objects to disk during the execution of an application program, if the application program `config`

ures them.

Allows Julia function calls to be temporarily overloaded for purpose of testing.

Memento is flexible hierarchical logging library for Julia.

CloudWatchLogs.jl provides easy access to CloudWatch Log Streams, and provides a Memento log handler.

A library for threaded and distributed parallelism.

A `RemoteSemaphore`

is a counting semaphore that lives on a particular process in order to control access to a resource from multiple processes.

Automated package testing infrastructure and distributed testing for Julia's master branch.

Compares a few implementation possibilities for a certain tasks in Julia to find out what's the fastest solution.

Provides `lift`

and `unlift`

functions.

This is a set of examples on how to embed a Rust library in a Julia package. Interfacing between Julia and Rust library is done using Rust's FFI: the Rust library is exposed as a C dynamic library, and Julia will call Rust functions using `ccall`

.

An Intermediate Representation (IR) on steroids.

Secure your Julia APIs with JWT.

Fontconfig.jl provides basic binding to fontconfig.

Showoff provides an interface for consistently formatting an array of n things, e.g. numbers, dates, unitful values.

Julia wrapper for AMD's RadeonProRender library.

Bindings to the Cairo graphics library.

This library generalizes and unifies the notion of measures used in Compose, Compose3D, and Escher.

FreeType bindings for Julia.

This package contains an "instrumenting profiler" for the Julia language. Profilers are mainly used for code optimization, particularly to find bottlenecks.

This package is useful for inspecting Julia's internals, particularly its MethodInstances and their backedges. See the documentation for details.

This package contains tools for visualizing and interacting with profiling data collected with Julia's built-in sampling profiler. It can be helpful for getting a big-picture overview of the major bottlenecks in your code, and optionally highlights lines that trigger garbage collection as potential candidates for optimization.

FlameGraphs is a package that adds functionality to Julia's Profile standard library. It is directed primarily at the algorithmic side of producing flame graphs, but includes some "format agnostic" rendering code.

CodeTracking can be thought of as an extension of Julia's InteractiveUtils library. It provides an interface for obtaining: the strings and expressions of method definitions, the method signatures at a specific file & line number, location information for "dynamic" code that might have moved since it was first loaded, a list of files that comprise a particular package.

SnoopCompile observes the Julia compiler, causing it to record the functions and argument types it's compiling. From these lists of methods, you can generate lists of `precompile`

directives that may reduce the latency between loading packages and using them to do "real work."

Progress meter for long-running operations in Julia

A CommonMark-compliant parser for Julia.

Maybe you have a module `X`

that depends on module `Y`

and you want using `X`

to pull in all of the symbols from `Y`

. Maybe you have an outer module `A`

with an inner module `B`

, and you want to export all of the symbols in `B`

from `A`

.

A Julia debugger.

This packages provides the `@infiltrate`

macro, which acts as a breakpoint with negligible runtime performance overhead.

An experimental simple method overlay mechanism for Julia.

Cthulhu can help you debug type inference issues by recursively showing the type-inferred code until you find the exact point where inference gave up, messed up, or did something unexpected.

An interpreter for Julia code.

Tools for manipulating Julia's lowered code.

The Julia debugger (now deprecated).

Rebugger is an expression-level debugger for Julia. It has no ability to interact with or manipulate call stacks (see Gallium), but it can trace execution via the manipulation of Julia expressions.

A package for analyzing source-code callgraphs, particularly of Julia's src/ directory.

A Julia package for choosing resources (hardware, libraries, algorithms) for performing computations. It exports a set of types that allow you to dispatch to different methods depending on the selected resources. It also includes simple facilities that help package authors manage the loading of code in a way that depends on resource availability and user choice.

This package contains simple utilities that may help debug julia code.

HeaderREPLs.jl is a Julia package that allows you to extend Julia's amazing REPL to support "mini-applications" that need to communicate more information to the user. They allow you to define a custom "header" type that you can use to print extra information above the prompt.

This package builds upon the VT100.jl package to provide automated testing of terminal based application. Both plain text and formatted output is supported.

This package explores a new approach to latency reduction in Julia. It determines the unique basic blocks present across a swath of Julia code and rewrites functions as calls to "fragments" that represent these blocks.

Save the result of macro-expanded functions to Julia files.

This package adds multi-threaded versions of functions operating on collections. Currently, the package contains the functions `foreach`

, `map`

, `reduce`

, `mapreduce`

, `mapfoldl`

, `mapfoldr`

.

This repository is deprecated; its only purpose is to provide a platform for the experimental Layout.jl which was written on top of this repository. Anyone starting fresh should use JuMP instead.

Easy everyday parallelism with a file tree abstraction.

Testing for Julia, simplified.

This package lets you customize the behavior of control statements like `if`

and `while`

by dispatching to user-defined functions based on the type of the predicate.

Write CUDA kernels as normal Julia functions.

A package for autoreloading files in Julia. Useful for interactive work. Modeled after IPython's autoreload extension.

Some benchmark optimization problems for testing new algorithms.

Inspired by the daemon-mode of Emacs, this package uses a server/client model. This allows julia to run scripts a lot faster, because the package is maintained in memory between the runs of (to run the same script several times).

Generate Jupyter-style MIME bundles for various types.

Values of the initial and final bits of a significand, in absolute and relative units.

Easily apply functions onto fields' values. Use a struct's fields as operands for operations on values of that type.

Characterizing functions applicable to windowed data streams.

@confirm is an @Assert you can vanish.

fjåge provides a lightweight and easy-to-learn framework for agent-oriented software development in Java and Groovy. Fjage.jl is a Julia port of fjåge, which can be independently used, or used in conjunction with a Java/Groovy container in a multi-language application.

AllocCheck.jl is a Julia package that statically checks if a function call may allocate by analyzing the generated LLVM IR of it and its callees using LLVM.jl and GPUCompiler.jl

Provides tools to help deploy/execute conventional applications in Julia.

Rematch.jl provides a syntax sugar for matching Julia values against syntactic patterns. The `@match`

macro expands a pattern-matching syntax into a series of if-elses that check the types and structure of the provided value, allowing you to more simply write checks that describe your intent.

Julia library for opening a file with the default application determined by the OS.

A Julia package for interacting with ANSI terminals.

Terming is a toolbox for manipulate terminals written in pure Julia. It offers low-level and elegant APIs to handle information directly from and work around with TTYs.

DisplayArray provides arrays that index character in text width unit. And therefore maintains an immutable display size for terminal emulators.

Create TerminalUserInterfaces in Julia.

Chairmarks measures performance hundreds of times faster than BenchmarkTools without compromising on accuracy.

MKL.jl is a Julia package that allows users to use the Intel MKL library for Julia's underlying BLAS and LAPACK, instead of OpenBLAS, which Julia ships with by default. Julia includes libblastrampoline, which enables picking a BLAS and LAPACK library at runtime.

This provides a Julia interface to some of the macOS Accelerate framework.

You have a julia script.jl and want to run it fast? Welcome to juliascript! It is build for exactly that purpose.

Sometimes you want to know more about what you’re working with, whether it be a function, type, value, or something else entirely. This package is a utility to help answer that question, it exports a single function `about`

, which can be applied to any Julia object.

Alternate random number generators based on ‘True’ random sources. Approximately a thousand times slower than the default Random.MersenneTwister generator, and relies on a network connection.

Julia’s errors are much less helpful than they could (or should, as some would say) be. Let’s try to bridge the gap a bit. This package is a prototype for functionality that I think should be in the Base language. This isn’t a complete solution, but I think it’s a step in the right direction.

A flexible foundation for basic user interaction.

A pure-Julia parser for (binary/compiled) terminfo files, with the accompanying terminfo data to be practically useful.

A pure-Julia implementation of the KangarooTwelve hashing scheme, so named because it consists of 12 rounds of Keccak (TurboSHAKE128) with kangaroo hopping, allowing for parallel tree-ish hashing termed “leaves stapled to a pole”.

A Julia docstring linter to check for various quality indications, taking into account the method(s) a docstring applies to.

Run a script many times, compile it once.

DotEnv.jl is a lightweight package that loads environment variables from .env files into =ENV=. Storing configuration in the environment is based on The Twelve-Factor App methodology.

Download files from the Internet and keep them up-to-date.

DataSets helps make data wrangling code more reusable.

DataToolkit is a batteries-included family of packages for robustly managing data.

This is a tiny package that allows data sets to be documented in the same manner as functions/variables.

Reproducible data setup for reproducible science.

This package exists to help you put and look for files in the appropriate place(s).

This provides Julia interface to the Message Passing Interface (MPI), roughly inspired by mpi4py.

At the core of Dagger.jl is a scheduler heavily inspired by Dask. It can run computations represented as directed-acyclic-graphs (DAGs) efficiently on many Julia worker processes and threads, as well as GPUs via DaggerGPU.jl.

GPU integrations for Dagger.jl.

Distributed table structures and data manipulation operations built on top of Dagger.jl

Support for different job queue systems commonly used on compute clusters.

MPIBenchmarks.jl is a collection of benchmarks for MPI.jl, the Julia wrapper for the Message Passing Interface (MPI).

Hwloc.jl is a high-level wrapper of the hwloc library. It examines the current machine's hardware topology (memories, caches, cores, etc.) and provides Julia functions to visualize and access this information conveniently.

DistributedArrays.jl uses the stdlib `Distributed`

to implement a Global Array interface. A `DArray`

is distributed across a set of workers. Each worker can read and write from its local portion of the array and each worker has read-only access to the portions of the array held by other workers.

Elly is a Hadoop HDFS and Yarn client.

In order for MPI calls to be made from a Julia cluster, it requires the use of `MPIManager`

, a cluster manager that will start the julia workers using `mpirun`

.

[Elemental.jl]ttps://github.com/JuliaParallel/Elemental.jl)

A package for dense and sparse distributed linear algebra and optimization. The underlying functionality is provided by the C++ library Elemental written originally by Jack Poulson and now maintained by LLNL.

This package provides a low level interface for PETSc and allows combining julia features (such as automatic differentiation) with the PETSc infrastructure and nonlinear solvers.

Tullio is a very flexible einsum macro. It understands many array operations written in index notation – not just matrix multiplication and permutations, but also convolutions, stencils, scatter/gather, and broadcasting.

This is an attempt to use Tullio.jl to run tensor expressions on Dagger-based distributed arrays.

A collection of utilities for messaging.

Simple distributed variant of `Base.Profile`

.

Computational problems can often be represented as specific types of graphs known as directed acyclic graphs (DAGs). That allows an execution framework to execute parts in right order, schedule in parallel, and make optimal use of available resources.

Add prefix `ThreadsX`

. to functions from Base to get some speedup, if supported.

Support for writing loop-based code that executes both on CPU and GPU.

Reliable Python-Julia interop.

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.

Allows Stata operations on Julia DataFrames by exporting it to Stata, running a .do file, and re-importing the result into Julia. Requires a copy of Stata.

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

Julia library aimed at simplifying conversion of legacy MATLAB/Octave code into Julia by providing functions similar to MATLAB/Octave.

This package provides two macros that are used to write JavaScript code inside of Julia programs.

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.

Julia <-> C++ Wrapper with Focus on Safety, Elegance, and Ease of Use.

This package aims to provide a Boost.Python-like wrapping for C++ types and functions to Julia. The idea is to write the code for the Julia wrapper in C++, and then use a one-liner on the Julia side to make the wrapped C++ library available there.

This package provides a Julia language wrapper for libclang: the stable, C-exported interface to the LLVM Clang compiler. The libclang API documentation provides background on the functionality available through libclang, and thus through the Julia wrapper. The repository also hosts related tools built on top of libclang functionality.

This package allows you to call and interact with GNU Octave, a mostly Matlab-compatible free-software numerical-computing language, from Julia. It works by directly accessing the GNU Octave C++ libraries using Cxx.jl, and hence should have performance comparable to calling Octave functions from within Octave.

ObjectiveC.jl is an Objective-C bridge for Julia.

Call Java programs from Julia.

This package provides access to Mathematica/Wolfram Engine via the MathLink library, now renamed to Wolfram Symbolic Transfer Protocol (WSTP).

This package provides interoperability between Julia and Common Language Runtime, the execution engine of .NET applications. Many languages run on CLR, including C#, Visual Basic .NET and PowerShell.

Halide is an promising project with an interesting design. I'm quite interested in seeing how some of their ideas work out when implemented in pure Julia, and preliminary experiments suggest that it may be possible to match the performance of Halide using pure Julia. The main purpose of this package, therefore, is for benchmark comparisons.

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.

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

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

A parquet file or dataset can be loaded using the `read_parquet`

function. A parquet dataset is a directory with multiple parquet files, each of which is a partition belonging to the dataset.

Read and write MATLAB files in Julia.

Read and write Stata, SAS and SPSS data files with Julia tables.

Imagine is an acquisition program for light sheet microscopy written by Zhongsheng Guo in Tim Holy's lab. This package implements a loader for the file format for the Julia programming language. Each Imagine "file" consists of two parts (as two separate files): a `*.imagine`

file which contains the (ASCII) header, and a `*.cam`

file which contains the camera data. The `*.cam`

file is a raw byte dump, and is compatible with the NRRD "raw" file.

A julia package to load images using bioformats.

This package aims to be a fast, minimal, and correct TIFF reader and writer written in Julia.

GIFImages.jl provides support for decoding and encoding GIF images by wrapping LibGif.

A Julia package for reading mass spectrometry mzXML files.

This package includes very basic support for loading GIFTI (.gii) files in Julia.

Julia module for reading/writing NIfTI MRI files.

Reading and writing of video files in Julia.

The LibPSF.jl module provides a pure-Julia implementation of Henrik Johansson's .psf reader.

The PSFWrite.jl module provides a pure-Julia .psf writer.

The SpiceData.jl module provides a pure-Julia SPICE data file reader inspired by Michael H. Perrott's CppSim reader.

This module provides support for reading and writing ZIP archives in Julia.

Read and write Zip archives in julia.

TAR files: create, list, extract them in pure Julia.

The NPZ package provides support for reading and writing Numpy .npy and .npz files in Julia.

This package supports loading 3D model file formats: obj, stl, ply, off and 2DM. More 3D model formats will be supported in the future.

Thin Wrapper for the library ImageMagick.

FileIO.jl integration for image files.

Exposes macOS's native image IO functionality to Julia.

This package supports the MetaImage file format for the Julia language.

SerialPorts.jl lets you work with devices over serial communication with Julia. It is designed to mimic regular file IO as in the Base Julia library.

libserialport is a small, well-documented C library for general-purpose serial port communication. This is a julia wrapper for the library.

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

CBOR.jl is a Julia package for working with the CBOR data format, providing straightforward encoding and decoding for Julia types.

Encode the image into a sixel control sequence and vice versa. If your terminal supports this format, then you can get a nice visualization of it.

Small and dependency free Julia package to infer file and MIME type checking the magic numbers signature.

Create a higher-dimensional array from lazily-loaded slices in separate files.

Reading and writing Windows-style INI files from Julia.

Snappy.jl is a Julia wrapper for the snappy library - a compression/decompression library focusing on speed.

This package is a light-weight Julia wrapper of libxml2.

This module exports two functions, adjust*crc and adjust*crc!, which allow you to write 4 bytes to a file or array in order to adjust the 32-bit CRC checksum (either CRC32 or CRC32c) to equal any desired value.

Julia bindings for libFLAC.

Julia interface to the Expat XML parser library.

Julia macros for suppressing and/or capturing output (`stdout`

), warnings (`stderr`

) or both streams at the same time.

Simple, consistent interfaces for any codec.

This module provides fast lossless compression for the Julia language by interfacing the Blosc Library.

Julia interface for blosc2 library.

HexEdit is a package for editing and displaying data in binary files in hexadecimal format.

Library to Check Type of Image.

Pcap contains libpcap bindings for Julia as well as logic to parse and extract useful data from packet captures.

This is a Julia package for working with metadata and storage associated with signals.

Generates IO methods (`pack`

, `unpack`

) from structure definitions. Also defines `packed_sizeof`

to give the on-disk size of a packed structure, which is smaller than `sizeof`

would give, if the struct is marked as `align_packed`

.

Wrapper for the Telegram API in Julia.

MsgPack.jl is a MessagePack implementation in pure Julia.

Zarr is a Julia package providing an implementation of chunked, compressed, N-dimensional arrays.

This is a Julia package that provides a compiler and a codec for Protocol Buffers. Protocol Buffers are a language-neutral, platform-neutral extensible mechanism for serializing structured data.

Julia Package for the FFMPEG builder binaries.

Save and load variables in Julia Data format (JLD).

A zstd codec for TranscodingStreams.jl.

Transcoding codecs for compression and decompression with LZ4.

A bzip2 codec for TranscodingStreams.jl.

An xz codec for TranscodingStreams.jl.

zlib codecs for TranscodingStreams.jl.

Base 16/32/64 codecs for TranscodingStreams.jl.

Wafefront Obj importer.

This package provides support for the CZI image format for microscopy in the Julia programming language. It is registered with the FileIO package.

This package formerly implemented compression, decompression plugins, and other filter plugins for HDF5.jl. bzip2, lz4, and zstd compression codecs were supported using CodecBzip2.jl, CodecLZ4.jl, and CodecZstd.jl.

The BSDiff package is a pure Julia implementation of the bsdiff tool for computing and applying binary diffs of files.

Package for reading NRRD files. Implements the FileIO interface.

This package implements the FileIO interface for loading and saving binary Netpbm images. Other packages, such as ImageMagick, also support such formats. One advantage of this package is that it does not have any binary (e.g., external library) dependencies–-it is implemented in pure Julia.

File IO for AVS format "field" data files with extension .fld for the Julia language, in conjunction with the FileIO package. This data format supports N-dimensional arrays of real numbers.

ArgTools provides tools for creating consistent, flexible APIs that work with various kinds of function arguments. In the current version, it helps deal with arguments that are, at their core, IO handles, but which you'd like to allow the user to specify directly as file names, commands, pipelines, or, of course, as raw IO handles. For write arguments, it's also possible to use `nothing`

and write to a temporary file whose path is returned.

BufferedStreams provides buffering for IO operations. It can wrap any IO type automatically making incremental reading and writing faster.

This implements support for reading Andor SIF image files in the Julia programming language.

Download files from Google Drive.

EzXML.jl is a package to handle XML/HTML documents for primates.

This module provides a wrapper for the gzip related functions of zlib, a free, general-purpose, legally unencumbered, lossless data-compression library. These functions allow the reading and writing of gzip files.

BSON.jl is a Julia package for working with the Binary JSON serialization format.

FileIO.jl integration for PNG files.

ConfParser is a package for parsing, modifying, and writing to configuration files. ConfParser can handle configuration files utilizing multiple syntaxes to include INI, HTTP, and simple.

This Julia package exports a type, `TextWidthLimiter <: IO`

, which can be used to limit output to no more than a specified number of characters.

Video player for Julia.

Attempt to make Toxcore accessible in Julia. Toxcore, ToxAv and ToxDNS have been wrapped.

A library for working with Org files.

This package provides utilities for reading & writing Google Firestore documents with Julia using the REST API.

Access newsapi.org from Julia.

IOStructs is a Julia package that helps write structs which represent (part of) a file format.

Accumulo.jl is a client library for Apache Accumulo, built using the Accumulo Thrift Proxy API.

A client for distributed SQL engines that provide a HiveServer2 interface. E.g.: Hive, Spark SQL, Impala.

An interface to PostgreSQL from Julia. Uses libpq (the C PostgreSQL API) and obeys the DBI.jl protocol.

LibPQ.jl is a Julia wrapper for the PostgreSQL libpq C library.

Redis.jl is a fully-featured Redis client for the Julia programming language. The implementation is an attempt at an easy to understand, minimalistic API that mirrors actual Redis commands as closely as possible.

DBInterface.jl provides interface definitions to allow common database operations to be implemented consistently across various database packages.

This package enables the use of Java JDBC drivers to access databases from within Julia. It uses the JavaCall.jl package to call into Java in order to use the JDBC drivers.

A Julia library for interacting with the ODBC API.

Pure Julia Lang implementation of a client for the ClickHouse TCP native API.

Package for interfacing with MySQL databases from Julia via the MariaDB C connector library, version 3.1.6.

A Julia interface to the sqlite library.

Mongoc.jl is a MongoDB driver for the Julia Language.

This package provides a driver to access Oracle databases using the Julia language, based on ODPI-C bindings.

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 package for representing sql queries, and converting them to valid SQL statements. The generated SQL statements follow the specification in https://www.sqlite.org/lang_select.html, and should conform to http://www.sqlstyle.guide/ as far as possible.

Wrapper over Python's SQLAlchemy library.

Octo.jl is an SQL Query DSL in Julia.

Directly interact with your local Zotero database.

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.

DataFrames.jl has a special mini-language for data transformations, which is powerful but often verbose.

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.

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.

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

A collection of type parsers and utilities for 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.

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

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.

This is a pure Julia implementation of the Apache Arrow data standard. This package provides Julia `AbstractVector`

objects for referencing data that conforms to the Arrow standard. This allows users to seamlessly interface Arrow formatted data with a great deal of existing Julia code.

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 julian implementation of sum types. Sum types, sometimes called 'tagged unions' are the type system equivalent of the disjoint union operation (which is not a union in the traditional sense). From a category theory perspective, sum types are interesting because they are dual to Tuples (whatever that means).

Sometimes you want a named tuple, but mutable.

A `KeyedFrame`

is a `DataFrame`

that also stores a vector of column names that together act as a unique key, which can be used to determine which columns to `join`

, `unique`

, and `sort`

on by default.

`LayerDict`

is an `Associative`

type that wraps a series of other associatives (e.g. `Dict`

s). When performing a lookup, a `LayerDict`

will look through its associatives in the order they were passed to the constructor until it finds a match. `LayerDict`

s are immutable—you cannot call `setindex!`

on them. However, you can update its wrapped associatives and those changes will be reflected in future lookups.

Tooling for manipulating multiline strings.

DateSelectors.jl simplifies the partitioning of a collection of dates into non-contiguous validation and holdout sets in line with best practices for tuning hyper-parameters, for time-series machine learning.

Non-iterable ranges.

Consistent operations over a collection of KeyedArrays.

JLSO is a storage container for serialized Julia objects. Think of it less as a serialization format but as a container, that employs a serializer, and a compressor, handles all the other concerns including metadata and saving. Such that the serializer just needs to determine how to turn a julia object into a `streamVector{UInt8}`

, and the compressor just needs to determine how to turn one stream of `UInt8`

s into a smaller one (and the reverse).

This package defines useful traits and methods for organising data into the format required by some API.

Functionality for working efficiently with block diagonal matrices. Note that non-square blocks are allowed, similarly to scipy.block_diag, but in contrast to the mathematical definition above.

Excel file reader/writer for the Julia language.

Provides a wrapper for BLPAPI Library to the Julia language.

This package provides a `split`

function for iterators.

Yet another Table / DataFrame like Julia package.

A Julia client for LDAP (Lightweight Directory Access Protocol) based on OpenLDAP library.

Encode/Decode your Julia structures to/from BSON.

This package provides types similar to Julia's `Rational`

type, which make some sacrifices but have better computational performance at the risk of greater risk of overflow.

Some NamedTuple utilities.

Fast fixed-size dicts wth eraseable keyed values where keys are sequential indicies.

JDF is a DataFrames serialization format with the following goals: fast save and load times, compressed storage on disk, enable disk-based data manipulation, supports machine learning workloads, e.g. mini-batch, sampling.

Douglass.jl is a package for manipulating DataFrames in Julia using a syntax that is very similar to Stata.

This package provides a few functions to conveniently flatten information stored in JSON format and convert it to DataFrames.

A Julia package for representing infinity in all its forms.

This library implements fixed-point number types. A fixed-point number represents a fractional, or non-integral, number. In contrast with the more widely known floating-point numbers, with fixed-point numbers the decimal point doesn't "float": fixed-point numbers are effectively integers that are interpreted as being scaled by a constant factor. Consequently, they have a fixed number of digits (bits) after the decimal (radix) point.

Math with 85+ accurate bits.

Provides the fixed-point decimal type FixedDecimal allowing for exact representations of decimal numbers. These numbers are useful in financial calculations where interactions between decimal numbers are required to be exact.

Finally a number type that you can count with your fingers. Super Mario and Zelda would be proud. Comes in two flavours: `Float8`

has 3 exponent bits and 4 fraction bits, `Float8_4`

has 4 exponent bits and 3 fraction bits. Both rely on conversion to Float32 to perform any arithmetic operation, similar to Float16.

This package defines the BFloat16 data type, a floating-point format with 1 sign bit, 8 exponent bits and 7 mantissa bits. Hardware implementation of this datatype is available in Google's Cloud TPUs as well as in a growing number of CPUs, GPUs, and more specialized processors. This package is suitable to evaluate whether using BFloat16 would cause precision problems for any particular algorithm, even without access to supporting hardware. Note that this package is designed for functionality, not performance, so this package should be used for precision experiments only, not performance experiments.

The DecFP package is a Julia wrapper around the Intel Decimal Floating-Point Math Library, providing a software implementation of the IEEE 754-2008 Decimal Floating-Point Arithmetic specification.

RoundingIntegers defines new integer types for the Julia programming language. Rounding integers act very much like regular integers, except that you can safely assign floating-point values to them. As the name suggests, such assignments cause rounding to the nearest integer.

The Decimals package provides basic data type and functions for arbitrary precision decimal floating point arithmetic in Julia. It supports addition, subtraction, negation, multiplication, division, and equality operations.

This is a Julia interface to libquadmath, providing a Float128 type corresponding to the IEEE754 binary128 floating point format.

Julia package for Roman numerals.

Uniform interface for positive definite matrices of various structures.

This is a package for extra Positive (Semi-) Definated Matrix types. It is an extension to PDMats.jl.

NamedDimsArray is a zero-cost abstraction to add names to the dimensions of an array.

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

This package provides tools for working with categorical variables, both with unordered (nominal variables) and ordered categories (ordinal variables), optionally with missing values.

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.

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.

AxisAlgorithms is a collection of filtering and linear algebra algorithms for multidimensional arrays. For algorithms that would typically apply along the columns of a matrix, you can instead pick an arbitrary axis (dimension).

This package provides support for the Woodbury matrix identity for the Julia programming language.

This package (not yet functional) for the Julia language will allow you to index arrays using names for the individual axes.

This repository contains a candidate next-generation interface for handling arrays in the Julia programming language. Its two (interconnected) advantages are: (1) it relaxes many of the assumptions built in to Julia's current array API; (2) it employs greater indirection to create new opportunities for both performance and flexibility.

This package provides efficient multidimensional implementations of two operators, restrict and prolong, which feature heavily in multigrid methods. In general terms, these operations reduce and increase, respectively, the size of arrays by a factor of 2 along one or more dimensions. The two operators satisfy the "Galerkin condition," meaning that as operators they are transposes of one another.

This package aims to evolve the means available to express array operations at a higher level than currently possible.

A Julia package for working more efficiently with strided arrays, i.e. dense arrays whose memory layout has a fixed stride along every dimension.

In optimization and machine learning, model parameters can be distributed across multiple arrays and can interact in complex ways. However, it can be useful to abstract away these details (e.g. when computing gradients) and collect all the parameters into a single vector. This is a lightweight package that enables you to switch between these two perspectives seamlessly.

GroupedArray is an AbstractArray that contains positive integers or missing values.

This package allows to generate complex array expressions based on the indices.

Allows an AbstractArray, to look like an AbstractArray with one more dimension and the tiles are represented along this dimension.

The Multivectors Julia package defines the Multivector Type to represent mixed-grade linear combinations of KVectors, which are in turn a vector space of Blades of a given grade. Multivectors is intended to be an implementation of Geometric Algebra, although it is useful for any Clifford algebra.

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

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.

Speedy customizable string interpolation for Julia.

A macro to add `isequal`

, `==`

, and `hash()`

to struct types: `@auto_hash_equals`

.

Automatically define accessor methods for fields of a type.

TimeSeries aims to provide a lightweight framework for working with time series data in Julia.

TimeSeries aims to provide a lightweight framework for working with time series data in Julia.

Get a column from a Vector, Matrix, 3D Array, DataFrame, or TimeSeries.

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

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.

Volatility models for time series.

Black-Scholes Option Pricing Formulae.

Tools for Term Structure of Interest Rates calculation, aimed at the valuation of financial contracts, specially Fixed Income instruments.

Tidier.jl is a 100% Julia implementation of the R tidyverse mini-language in Julia. Powered by the DataFrames.jl package and Julia’s extensive meta-programming capabilities, Tidier.jl is an R user’s love letter to data analysis in Julia.

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

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.

A library for creating 2D vector graphics in layers. Check out the documentation!

Animations.jl offers an easy way to set up simple animations where multiple keyframes are interpolated between in sequence. You can choose different easing functions or create your own. Keyframe values can be anything that can be linearly interpolated, you can also add your own methods for special types. An easing can have repetitions and delays, so that looping animations are simpler to create.

This package implements an algorithm for quickly computing signed distance fields in 2D.

Immerse is a wrapper that adds graphical interactivity to Julia plots. Currently, Immerse supports Gadfly.

Convert any matrix into a braille or block Unicode string, real fast and dependency free.

Draw text into a Matrix.

This is intended for experiments with graphical layout management in Julia.

VTKView wraps vtkfig, a C++ graphics library with an API that attempts to be easy to use from C/C++ simulation codes. It uses vtk for fast rendering of data. Based on ccall and the C API of vtkfig, VTKView makes this functionality available in Julia..

The ModelingToolkitDesigner.jl package is a helper tool for visualizing and editing ModelingToolkit.jl system connections.

The Fractal Animation Engine, Fae.jl, is an open research project with the goal of creating a new, general purpose rendering engine based on Iterated Function Systems (IFS). The principle is simple: an IFS can draw any object with the right set of equations, so if we can find that set of equations, we can render dynamic scenes.

Centripetal parameterization for Catmull-Rom interpoint connectivity.

Save Plots.jl figures easily in multiple formats and sizes.

GUI building, using the Gtk library: https://www.gtk.org/

GtkObservables is designed to simplify the creation of graphical user interfaces (GUIs) using Gtk and Julia.

GUI building using the GTK library, version 4.

Interactive Makie plots in Gtk4 windows.

Mousetrap is a GUI library for Julia. It, and its stand-alone C++-component of the same name, fully wrap GTK4 (which is written in C), vastly simplifying its interface to improve ease-of-use without sacrificing flexibility.

This package is a collection of extensions to Gtk that make interactive graphics easier.

GtkSourceWidget.jl is a Julia wrapper for the Gtk library GtkSourceView that allows showing source code documents.

A widget to display simple markdown formatted text.

GtkReactive is designed to simplify the creation of graphical user interfaces (GUIs) using Gtk and Julia.

Julia interface to the Tk windowing toolkit.

This package is maintained by the JuliaGraphics group and provides an interface to Qt6 QML (and to Qt5 for older versions). It uses the CxxWrap package to expose C++ classes. Current functionality allows interaction between QML and Julia using Observables, ListModels and function calling. There is also a generic Julia display, as well as specialized integration for image drawing, GR plots and Makie.

Blink.jl is the Julia wrapper around Electron. It can serve HTML content in a local window, and allows for communication between Julia and the web page. In this way, therefore, Blink can be used as a GUI toolkit for building HTML-based applications for the desktop.

Electron.jl wraps the cross-platform desktop application framework Electron. You can use it to build GUI applications in Julia.

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

This package is a developer target and it includes the implementation of Interact widgets.

Unified interface for widgets.

Escher has been repurposed to be a metapackage around Interact.jl and other packages for web deployment (so far it includes Mux.jl but more things may be added as they become available).

Reactive.jl is a package for reactive programming in Julia.

Fun toys built on top of JuliaGizmos projects!

This package provides a Julia language wrapper for cimgui: a thin c-api wrapper programmatically generated for the excellent C++ immediate mode gui Dear ImGui.

Plotting for Julia based on GR, a framework for visualization applications.

This package is an experimental refactoring of the module jlgr from GR.jl, intended to provide the main utilities of jlgr in a more "Julian" and modular style, easy to read, and facilitate code contributions by others.

Plots - powerful convenience for visualization in Julia.

This package provides a collection of colorschemes.

This package provides tools for working with colorschemes and colormaps. It's a companion to the ColorSchemes.jl package.

This library provides a wide array of functions for dealing with color. This includes conversion between colorspaces, measuring distance between colors, simulating color blindness, parsing colors, and generating color scales for graphics.

Colors.jl supports about 660 colors as named colorants. NamedColors.jl supports about 4,000. Honestly, the named colors in Colors.jl, and/or its capacity to generate good palettes, are far more useful.

This "minimalistic" package serves as the foundation for working with colors in Julia. It defines basic color types and their constructors, and sets up traits and `show`

methods to make them easier to work with.

This package is an add-on to ColorTypes, and provides fast mathematical operations for objects with types such as `RGB`

and `Gray`

. Specifically, with this package both grayscale and `RGB`

colors are treated as if they are points in a normed vector space.

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

Generic helper algorithms for building plotting components.

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.

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

and `*`

.

Graphics.jl is an abstraction layer for graphical operations in Julia.

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.

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.

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.

Compose3D is a Julia package written to try and extend Compose to 3-D.

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)

Isoband.jl wraps isoband_jll, which gives access to wilkelab's isoband package, which powers contour plots in ggplot.

The package started by copying the method shared by Keno Fischer here and then extended to catering for each of the different types of shapefile (polygons, polylines, points, multipoints and their variants but does not currently support the Multipatch type) as well as overlaying the image onto a Google map.

TidierPlots.jl is a 100% Julia implementation of the R package ggplot in Julia. Powered by the AlgebraOfGraphics.jl, Makie.jl, and Julia’s extensive meta-programming capabilities, TidierPlots.jl is an R user’s love letter to data visualization in Julia.

Plotting extension library that can be used in conjunction with CImGui.jl to provide enhanced immediate-mode data visualization.

Interactive visualization tools for Julia.

PlotAxes is intended to simplify the visualization of medium dimensional data (e.g. 4-5 dimensions max) during an interactive session. It is not intended as a full fledged plotting API for publication quality graphs.

Fast, interactive Julia/GTK+ plots (+Smith charts +Gtk widget +Cairo-only images).

The GracePlot.jl module is a simple control interface for Grace/xmgrace - providing more publication-quality plotting facilities to Julia.

CMDimData.jl provides a high-level abstraction to manipulate multi-dimensional data, and automatically interpolate intermediate values as if it was a continuous function.

Elegant data visualization for Julia.

A Julia package for plotting Heatmaps with marginal dendrograms, in Gadfly.

Experimental rewrite of PlotlyLight.jl.

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.

Algorithms for finding a non-overlapping set of cliques in a graph represented by an adjacency matrix.

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.

Convert julia objects to LaTeX equations, arrays or other environments.

Convex.jl is a Julia package for Disciplined Convex Programming (DCP). Convex.jl can solve linear programs, mixed-integer linear programs, and DCP-compliant convex programs using a variety of solvers, including Mosek, Gurobi, ECOS, SCS, and GLPK, through MathOptInterface. Convex.jl also supports optimization with complex variables and coefficients.

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.

Basic arithmetic, integration, differentiation, evaluation, root finding, and fitting for univariate polynomials in Julia.

Interval Sets for Julia.

Numerical routines for computing Bessel, Airy, and Hankel functions for real arguments. These routines are written in the Julia programming language and are self contained without any external dependencies.

This package contains simple routines for finding roots, or zeros, of scalar functions of a single real variable using floating-point math.

The Richardson package provides a function extrapolate that extrapolates any function f(x) to f(x0), evaluating f only at a geometric sequence of points > x0 (or optionally < x0) or at a given sequence of points. f(x) can return scalars, vectors, or any type implementing a normed vector space.

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 library adds several functions useful for doing math on integers. Most of these are GMP wrappers that may have faster implimentations for smaller integer types.

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.

The HCubature module is a pure-Julia implementation of multidimensional "h-adaptive" integration.

This package provides an implementation of the generalized hypergeometric function pFq(α, β, z).

This Julia package defines the Tau constant and related functions.

This package defines an interface for mathematical/statistical densities and objects associated with a density in Julia.

This package is intended as a lightweight foundation for tensor operations across the Julia ecosystem.

ChangesOfVariables.jl defines functionality to calculate volume element changes for functions that perform a change of variables (like coordinate transformations).

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

The Xsum package is a Julia wrapper around Radford Neal's xsum package for exactly rounded double-precision floating-point summation.

This package provides functions to compute fast Walsh-Hadamard transforms in Julia, for arbitrary dimensions and arbitrary power-of-two transform sizes, with the three standard orderings: natural (Hadamard), dyadic (Paley), and sequency (Walsh) ordering.

This package provides a macro `@fastpow`

that can speed up the computation of integer powers in any Julia expression by transforming them into optimal sequences of multiplications, with a slight sacrifice in accuracy compared to Julia's built-in x^n function. It also optimizes powers of the form `1^p`

, `(-1)^p`

, `2^p`

, and `10^p`

.

Julia wrapper for the GNU Scientific Library (GSL), for Julia v1.0+. Currently uses GSL v2.7.

This package implements some numerical methods for computing inverse Laplace transforms in Julia.

ULP testing for Floating Point special functions.

This package provides variants of `sum`

and `cumsum`

, called `sum_kbn`

and `cumsum_kbn`

respectively, using the Kahan-Babuska-Neumaier (KBN) algorithm for additional precision. These functions are typically slower and less memory efficient than `sum`

and `cumsum`

.

Lambert W function and associated omega constant.

Mittag-Leffler function.

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.

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.

This module provides one- and multi-dimensional adaptive integration routines for the Julia language, including support for vector-valued integrands and facilitation of parallel evaluation of integrands, based on the Cubature Package by Steven G. Johnson.

This package provides a fast implementation of the integer-valued, base-2 logarithm. `ilog2`

supports other types of numbers, as well. It also provides `checkispow2`

.

This package aims to make it easier to detect overflow in numeric computations. It exports two macros, `@check`

and `@checked`

, as well as functions `accumulatortype`

and `acc`

. Packages can add support for their own types to interact appropriately with these tools.

Floating point math with error-free, faithful, and compensated transforms.

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.

This (relatively) light-weight package contains core functionality of MeasureTheory. Many packages using or defining measures do not need the full capabilities of MeasureTheory.jl itself, and can depend on this instead.

MeasureTheory.jl is a package for building and reasoning about measures.

Julia functions for computing prime numbers.

A general framework for fast Fourier transforms (FFTs) in Julia.

This package provides Julia bindings to the FFTW library for fast Fourier transforms (FFTs), as well as functionality useful for signal processing. These functions were formerly a part of Base Julia.

This module provides a function to compute the zeros of the Bessel J and K functions, that is Bessel functions of the first and second kind.

Random matrix package for Julia. This extends the Distributions package to provide methods for working with matrix-valued random variables, a.k.a. random matrices. State of the art methods for computing random matrix samples and their associated distributions are provided.

RandomizedLinAlg.jl is a Julia package that provides randomized algorithms for numerical linear algebra.

IterativeSolvers is a Julia package that provides iterative algorithms for solving linear systems, eigensystems, and singular value problems.

Special mathematical functions in Julia, include Bessel, Hankel, Airy, error, Dawson, exponential (or sine and cosine) integrals, eta, zeta, digamma, inverse digamma, trigamma, and polygamma functions. Most of these functions were formerly part of Base in early versions of Julia.

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.

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.

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

This package only contains and exports a single function `realdot(x, y)`

. It computes `real(LinearAlgebra.dot(x, y))`

while avoiding computing the imaginary part of `LinearAlgebra.dot(x, y)`

if possible.

This package provides bindings to the Intel MKL Vector Mathematics Functions. This is often substantially faster than broadcasting Julia's built-in functions, especially when applying a transcendental function over a large array.

This package defines irrational constants.

Julia implementation of the Non-equidistant Fast Fourier Transform (NFFT).

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.

SymbolicUtils.jl provides various utilities for symbolic computing. SymbolicUtils.jl is what one would use to build a Computer Algebra System (CAS). If you're looking for a complete CAS, similar to SymPy or Mathematica, see Symbolics.jl. If you want to build a crazy CAS for your weird Octonian algebras, you've come to the right place.

This package extends SymbolicUtils expression simplification with a theorem prover.

Metatheory.jl is a general purpose term rewriting, metaprogramming and algebraic computation library for the Julia programming language, designed to take advantage of the powerful reflection capabilities to bridge the gap between symbolic mathematics, abstract interpretation, equational reasoning, optimization, composable compiler transforms, and advanced homoiconic pattern matching features. The core features of Metatheory.jl are a powerful rewrite rule definition language, a vast library of functional combinators for classical term rewriting and an e-graph rewriting, a fresh approach to term rewriting achieved through an equality saturation algorithm. Metatheory.jl can manipulate any kind of Julia symbolic expression type, as long as it satisfies the TermInterface.jl.

This package contains definitions for common functions that are useful for symbolic expression manipulation. Its purpose is to provide a shared interface between various symbolic programming Julia packages, for example SymbolicUtils.jl, Symbolics.jl and Metatheory.jl.

This package contains definitions for common combinators that are useful for symbolic expression rewriting. Its purpose is to provide a shared library of combinators between various symbolic programming Julia packages, for example SymbolicUtils.jl, Symbolics.jl and Metatheory.jl.

Maxima.jl is a Julia package for performing symbolic computations using Maxima. Maxima is computer algebra software that provides a free and open source alternative to proprietary software such as Mathematica, Maple and others.

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 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 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.

Knuth-Bendix completion algorithm.

SpecialSets provides implementations of sets commonly used in mathematics, as well as the logic for cleanly combining such sets.

Simplify.jl implements methods for symbolic algebraic simplification in the Julia language.

Conjugates.jl is a simple little utility for doing algebraic operations between an object and its ‘conjugate’, either Hermitian conjugate or transpose.

This is a package-in-progress in which I am implementing the DMRG algorithm over matrix product states as explained in Schollwöck’s The density-matrix renormalization group in the age of matrix product states. A similar project has been undertaken in LatticeSweeper.jl.

Simple two-site DMRG. No support for quantum number conservation.

This is a package I'm throwing together after getting inspired by the talk Physics in Clojure which was about porting scmutils to clojure. scmutils is a Scheme package with a very interesting and powerful computer algebra system meant as a companion to the book Structure and Interpretation of Classical Mechanics.

Experimental tracing for SymbolicUtils.jl types. SymbolicTracing.jl will allow you to effectively treat `Symbolic{T}`

as being a subtype of `T`

for the purposes of dispatch if `T`

is an abstract type.

This package is a playground for learning about Geometric Algebra (GA), and intends to leverage Julia's powerful Linear Algebra ecosystem to compute quantities in GA using matrices as a backend.

In a paper, Tupper presents a method for graphing two-dimensional implicit equations and inequalities. This package gives an implementation of the paper's basic algorithms to allow the Julia user to naturally represent and easily render graphs of implicit functions and equations.

A library that implements Jacobi polynomials and Gauss quadrature related operations.

QuadDIRECT is an algorithm for global optimization without requiring derivatives.

LinearCovarianceModels.jl is a package for computing Maximum Likelihood degrees and MLEs of linear covariance models using numerical nonlinear algebra. In particular HomotopyContinuation.jl.

Implementation of hemireal arithmetic for Julia.

Matrix factorizations over the hemireals.

This is an implementation of Multilevel Coordinate Search (MCS), an algorithm by Waltraud Huyer and Arnold Neumaier for global minimization over a possibly-bounded domain. In a recent comparison of global optimization routines that do not require derivatives, MCS scored highest among non-commercial algorithms.

Pure-Julia quadratically-constrained quadratic programming solvers.

PositiveFactorizations is a package for computing a positive definite matrix decomposition (factorization) from an arbitrary symmetric input.

Pseudoinverse from a Bunch-Kaufman factorization.

Accurate and efficient full-degree multidimensional polynomial interpolation.

Julia implementation of the Simplex algorithm for rational numbers. Intended for educational and experimental purposes only. See code for documentation, or tests for examples.

Generate random correlation matrices, for some definition of random.

JuMPeR is a modeling language for robust optimization. It is embedded in the Julia programming language, and is an extension to the JuMP modeling language.

Gridap provides a set of tools for the grid-based approximation of partial differential equations (PDEs) written in the Julia programming language. The library currently supports linear and nonlinear PDE systems for scalar and vector fields, single and multi-field problems, conforming and nonconforming finite element (FE) discretizations, on structured and unstructured meshes of simplices and n-cubes. It also provides methods for time integration. Gridap is extensible and modular. One can implement new FE spaces, new reference elements, use external mesh generators, linear solvers, post-processing tools, etc.

The visualization of numerical results is an important part of finite element (FE) computations. However, before the inception of GridapMakie.jl, the only approach available to data visualization of Gridap.jl computations was to write simulation data to data files (e.g., in vtu format) for later visualization with, e.g., Paraview or VisIt.

Solve a Poisson problem with Gridap on top of a Finite Element mesh generated by GMSH. The mesh includes two physical groups, "`boundary1`

" and "`boundary2`

", which are used to define boundary conditions. This is just a simple demo. Once the GMSH mesh is read, all the magic of Gridap can be applied to it.

This is a repository for the Google Summer of Code project on Differentiable Tensor Networks. It implements one function that both computer scientists and physicists love, the Einstein summation.

Fast tensor operations using a convenient Einstein index notation.

Dynamic Time Warping (DTW) and related algorithms in Julia.

Some nonnegative least squares solvers in Julia.

This package exports a single macro `@einsum`

, which implements similar notation to the Einstein summation convention to flexibly specify operations on Julia `Arrays`

, similar to numpy's einsum function (but more flexible!).

The Fresa package implements a plant propagation algorithm for black-box optimization.

These integer types do not ignore arithmetic overflows and underflows.

Rationals with unreal performance.

When computing the arc separating two cartesian vectors, this is robustly stable; others are not.

These IEEE Floats may be marked, cleared, remarked with any one of a few colors/tags.

For multiprecision numerical computing using values with 25..2,500 digits. With arithmetic and higher level mathematics, this package offers you the best balance of performance and accuracy.

Arithmetic with the InfInt type saturates ±Infinty, so there is no overflow or underflow.

Error-free transformations are used to get results with extra accuracy.

Error-free transformations enfold accuracy, careful design speeds computation.

Create a more performant, less demanding analog of Double64s.

A more robust Float32 that preserves float performance.

Faster directed rounding for inline arithmetic.

More performant min, max, minmax with simpler native code.

Simplifies the use of quiet NaNs to propagate information from within numerical computations.

Floats with neither Infinities nor NaNs.

IEEE754-2019 structural introspection for Float8, Float16, Float32, Float64, Float128.

Float32 results are computed using Float64s.

XFloats exports two these two types: XFloat16, XFloat32. These floating point types correspond to Float16 and Float32. Use them to compute results with greater accuracy at very high speed.

Make extended precision numbers readable.

Manipulate sign, exponent, significand of Float64, Float32, Float16 values.

Extra floating point functions.

Roots and Extrema of the Four Kinds of Chebyshev Polynomials.

Signed and Unsigned Integers, individually [un]markable.

Xirshiro algorithms for pseudorandom UInt32|64, Int32|64.

Floats that are markable, unmarkable and remarkable.

More is**(this) and paired not**(this)__

Round floating point arithmetic as you direct.

These arithmetic functions provide the usual higher order result and additionally provide the lower order value extending the accuracy and precison of the calculation.

Additional support for Nothing.

Sort 1..25 values with conditional swaps.

Nonnegative integers.

ThieleFourPointInterpolation.jl

Rational interpolation using four given points.

Romu family of pseudo-random number generators.

Diagonalizations.jl is a Julia signal processing package implementing several closed form and iterative diagonalization procedures for both real and complex data input

Tools for deriving new Runge–Kutta methods.

MultiFloats.jl is a Julia package for extended-precision arithmetic using 100 - 400 bits (≈ 30 - 120 digits). In this range, it is the fastest extended-precision library that I am aware of. At 100-bit precision, MultiFloats.jl is roughly 40x faster than BigFloat and 2x faster than DoubleFloats.jl.

DZOptimization.jl is a Julia package for smooth nonlinear optimization that emphasizes performance, flexibility, and memory efficiency. In basic usage examples (see below), DZOptimization.jl has 6x less overhead and uses 10x less memory than Optim.jl.

This package is a Julia interface to the PRIMA library, a Reference Implementation for Powell's Methods with Modernization and Amelioration, by Zaikun Zhang who re-implemented and improved algorithms originally by M.J.D. Powell for minimizing a multi-variate objective function possibly under constraints and without derivatives.

This package provides a Julia interface for NOMAD, which is a C++ implementation of the Mesh Adaptive Direct Search algorithm (MADS), designed for difficult blackbox optimization problems. These problems occur when the functions defining the objective and constraints are the result of costly computer simulations.

BlackBoxOptim is a global optimization package for Julia (http://julialang.org/). It supports both multi- and single-objective optimization problems and is focused on (meta-)heuristic/stochastic algorithms (DE, NES etc) that do NOT require the function being optimized to be differentiable. This is in contrast to more traditional, deterministic algorithms that are often based on gradients/differentiability. It also supports parallel evaluation to speed up optimization for functions that are slow to evaluate.

Trixi.jl is a numerical simulation framework for conservation laws written in Julia. A key objective for the framework is to be useful to both scientists and students. Therefore, next to having an extensible design with a fast implementation,

Yeppp! is a high-performance SIMD-optimized mathematical library. This Julia package makes it possible to call Yeppp from Julia.

This package contains various functions that are useful for working with and in Fourier space.

Calculates multidimensional functions faster by exploiting their separability.

Fast Interpolation for Volume Datasets.

DiscreteDifferentialGeometry.jl

The DiscreteDifferentialGeometry Julia package defines Types and methods to implement Discrete Differential Geometry.

The HalfEdges Julia package defines the HalfEdges type and methods/types to implement operations on the halfedge data structure.

Laplacians is a package containing graph algorithms, with an emphasis on tasks related to spectral and algebraic graph theory. It contains (and will contain more) code for solving systems of linear equations in graph Laplacians, low stretch spanning trees, sparsifiation, clustering, local clustering, and optimization on graphs.

Interface to the MOSEK solver in Julia.

Code for solving systems of linear equations in nonsingular, symmetric, block diagonally dominant (BDD) matrices. This family includes Laplacians, SDDM matrices, and Connection Laplacians.

A Julia package for manipulating data in the Riemannian manifold of positive definite matrices.

A Julia Package for Machine Learning on the Manifold of Positive Definite Matrices.

This is a Julia wrapper for the dierckx Fortran library, the same library underlying the spline classes in scipy.interpolate. Some of the functionality here overlaps with Interpolations.jl, a pure-Julia interpolation package. Take a look at it if you have a use case not covered here.

Julia Wrappers for SymEngine, a fast symbolic manipulation library, written in C++.

The Fresa package implements a plant propagation algorithm for black-box optimization.

This package is a toolbox for Frank-Wolfe and conditional gradients algorithms.

Implements Singular Value Decomposition for generic number types, such as `BigFloat`

, `Complex{BigFloat}`

or `Quaternion`

s. It internally overloads several Base functions such that existing methods (`svd`

, `svdfact`

and `svdvals`

) should work directly.

This repo contains Arpack built against the MKL binaries. The module presents as ArpackMKL to Julia, but the underlying binary is still called libarpack.

This package provides a flexible framework for hierarchical data types in Julia.

This repo plans to provide a low-level Julia wrapper for BLIS typed interface.

BLISBLAS.jl is a Julia package that allows users to use the BLIS library for Julia's underlying BLAS. Note that BLIS only provides BLAS but not LAPACK (OpenBLAS will still be used for LAPACK functionality).

A simple package that depends on OpenBLAS32_jll, and sets up the forwarding for LP64 BLAS symbols on 64-bit architectures using libblastrampoline that ships with Julia.

A multi-threaded LU implementation.

A few preconditioners for iterative solvers.

This package provides support for the Woodbury matrix identity for the Julia programming language. This is a generalization of the Sherman-Morrison formula. Note that the Woodbury matrix identity is notorious for floating-point roundoff errors, so be prepared for a certain amount of inaccuracy in the result.

The purpose of this package is partly to extend linear algebra functionality in base to cover generic element types, e.g. `BigFloat`

and `Quaternion`

, and partly to be a place to experiment with fast linear algebra routines written in Julia (except for optimized BLAS). It is my hope that it is possible to have implementations that are generic, fast, and readable.

Julia wrapper for the arpack library designed to solve large-scale eigenvalue problems.

IncrementalSVD provides incremental (updating) singular value decomposition. This allows you to update an existing SVD with new columns, and even implement online SVD with streaming data.

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

A Julia package for the Rectangular Full Packed (RFP) matrix storage format.

Octavian.jl is a multi-threaded BLAS-like library that provides pure Julia matrix multiplication on the CPU, built on top of LoopVectorization.jl.

This Julia package provides fast low-rank approximation algorithms for BLAS/LAPACK-compatible matrices based on some of the latest technology in adaptive randomized matrix sketching.

RecursiveFactorization.jl is a package that collects various recursive matrix factorization algorithms.

This package is an offshoot of LowRankApprox.jl, and provides the `LowRankMatrix`

type that is used in that package. It should be a lightweight dependency if you only need to use a `LowRankMatrix`

without the functionality provided by LowRankApprox.jl.

The SkewLinearAlgebra package provides specialized matrix types, optimized methods of LinearAlgebra functions, and a few entirely new functions for dealing with linear algebra on skew-Hermitian matrices, especially for the case of real skew-symmetric matrices.

Truncated singular value decomposition with partial reorthogonalization.

The Arnoldi Method with Krylov-Schur restart, natively in Julia.

A Julia package to contain non-standard matrix factorizations. At the moment it implements the QL, RQ, and UL factorizations, a combined Cholesky factorization with inverse, and polar decompositions. In the future it may include other factorizations such as the LQ factorization.

A Julia package for working with special matrix types. This Julia package extends the LinearAlgebra library with support for special matrices that are used in linear algebra. Every special matrix has its own type and is stored efficiently. The full matrix is accessed by the command `Matrix(A)`

.

A Julia package for representing block-banded matrices and banded-block-banded matrices. This package supports representing block-banded and banded-block-banded matrices by only storing the entries in the non-zero bands.

A Julia package to represent semiseparable and almost banded matrices.

An extensible test matrix collection for Julia.

This package lets you solve sparse linear systems using Algebraic Multigrid (AMG). This works especially well for symmetric positive definite matrices.

A Julia package for representing banded matrices.

This package supports lazy banded and block-banded matrices, for example, a lazy multiplication of banded matrices.

A Julia package for describing array layouts and more general fast linear algebra.

A Julia package for defining and working with linear maps, also known as linear transformations or linear operators acting on vectors. The only requirement for a LinearMap is that it can act on a vector (by multiplication) efficiently.

A Julia repository for linear algebra with infinite banded and block-banded matrices.

This package implements permutations and some functions of them.

This package defines a Permutation type for Julia. We only consider permutations of sets of the form `{1,2,3,...,n}`

where n is a positive integer.

This Julia package provides functions for computing sparse (or "pruned") fast Fourier transforms (FFTs) in one (1D) and two (2D) dimensions.

Core definitions for the ProximalOperators and ProximalAlgorithms ecosystem.

A Julia package for non-smooth optimization algorithms. This package provides algorithms for the minimization of objective functions that include non-smooth terms, such as constraints or non-differentiable penalties.

Proximal operators for nonsmooth optimization in Julia. This package can be used to easily implement proximal algorithms for convex and nonconvex optimization problems such as ADMM, the alternating direction method of multipliers.

A Julia package for manipulation of univariate piecewise quadratic functions.

A Julia package that solves Linearly Constrained Separable Optimization Problems using ADMM.

StructuredOptimization.jl is a high-level modeling language that utilizes a syntax that is very close to the mathematical formulation of an optimization problem.

Tulip is an open-source interior-point solver for linear optimization, written in pure Julia. It implements the homogeneous primal-dual interior-point algorithm with multiple centrality corrections, and therefore handles unbounded and infeasible problems. Tulip’s main feature is that its algorithmic framework is disentangled from linear algebra implementations. This allows to seamlessly integrate specialized routines for structured problems.

Fortuna.jl is a general-purpose Julia package for structural and system reliability analysis.

This repository contains a port of the CUFSM package, primarily developed by Dr. Benjamin W. Schafer, from MATLAB to Julia. This port enables users to perform automatic differentiation through any part of its code, facilitating the optimization of cold-formed steel section topologies for strength, stiffness, and other desired parameters.

Swiss knife for machine learning.

A Machine Learning Framework for Julia. MLJ (Machine Learning in Julia) is a toolbox written in Julia providing a common interface and meta-algorithms for selecting, tuning, evaluating, composing and comparing about 200 machine learning models written in Julia and other languages.

Repository for developers that provides core functionality for the MLJ machine learning framework. MLJ is a Julia framework for combining and tuning machine learning models. This repository provides core functionality for MLJ.

Repository of the "built-in" models available for use in the MLJ MLJ machine learning framework; and the home of the MLJ model registry.

MLJ is a Julia framework for combining and tuning machine learning models. MLJFlow is a package that extends the MLJ capabilities to use MLflow as a backend for model tracking and experiment management. To be specific, MLJFlow provides a close to zero-preparation to use MLflow with MLJ; by the usage of function extensions that automate the MLflow cycle (create experiment, create run, log metrics, log parameters, log artifacts, etc.).

A base Julia interface for machine learning and statistics.

A light-weight package defining fall-back implementations for a collection of traits possessed by statistical objects. Here a "trait" is a function with a single argument that is a julia type, which might encode type metadata for inspection, or for use in function dispatch.

Multi-language suite for high-performance solvers of differential equations and scientific machine learning (SciML) components. Ordinary differential equations (ODEs), stochastic differential equations (SDEs), delay differential equations (DDEs), differential-algebraic equations (DAEs), and more in Julia.

High-performance and differentiation-enabled nonlinear solvers (Newton methods), bracketed rootfinding (bisection, Falsi), with sparsity and Newton-Krylov support.

A light-weight, dependency-free, Julia interface defining a collection of types (without instances) for implementing conventions about the scientific interpretation of data.

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

Partial implementation of the OpenML API for Julia. At present this package allows querying and downloading of OpenML datasets.

Flux is an elegant approach to machine learning. It's a 100% pure-Julia stack, and provides lightweight abstractions on top of Julia's native GPU and AD support. Flux makes the easy things easy while remaining fully hackable.

Metalhead.jl provides standard machine learning vision models for use with Flux.jl. The architectures in this package make use of pure Flux layers, and they represent the best-practices for creating modules like residual blocks, inception blocks, etc. in Flux. Metalhead also provides some building blocks for more complex models in the Layers module.

A deep learning package for supervised learning built in Julia.

Utilities for Machine Learning in Julia (ROC Curve, Confusion Matrix).

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

The Deep Learning Framework.

LuxCUDA is meant to be used as a trigger package for all CUDA dependencies in Lux. Users requiring CUDA support should install LuxCUDA and load it alongside Lux.

LuxAMDGPU is meant to be used as a trigger package for all AMDGPU dependencies in Lux. Users requiring AMDGPU support should install LuxAMDGPU and load it alongside Lux.

This package is a light dependency providing common weight initialization schemes for deep learning models.

Accelerate your ML research using pre-built Deep Learning Models with Lux.

Avalon is a deep learning library in Julia with focus on high performance and interoperability with existing DL frameworks.

Yota.jl is a package for reverse-mode automatic differentiation in Julia.

SimpleChains.jl only supports simple chains, but it intends to be fast for small problems on the CPU.

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.

Lathe.jl is an all-in-one package for predictive modeling in Julia. It comes packaged with a Stats Library, Preprocessing Tools, Distributions, Machine-Learning Models, and Model Validation. Lathe features easy object-oriented programming methodologies using Julia's dispatch.

A minimal utility for working with AWS Sagemaker hyperparameters. More broadly for dealing with environment variables.

Keras.jl uses PyCall.jl to build a julia wrapper around the python neural network library keras.

ParameterHandling.jl is an experiment in handling constrained tunable parameters of models.

FeatureTransforms.jl provides utilities for performing feature engineering in machine learning pipelines with support for `AbstractArray`

s and `Table`

s.

FeatureDescriptors.jl is an interface package for describing features used in models, feature engineering, and other data-science workflows.

A package for Maximum Likelihood Estimation in various models using Expectation Maximisation and gradient descent.

An interface package that defines the methods and types for working with models.

Nabla.jl is a reverse-mode automatic differentiation package targetting machine learning use cases. As such, we have (for example) prioritised support for linear algebra optimisations and higher-order functions over the ability to take higher-order derivatives (Nabla currently only supports first-order derivatives).

An implementation of the t-Sne algorithm. The main author (Laurens van der Maaten) has information on t-Sne (including papers and links to other implementations) here.

A set of standard datasets in Multi-instance learning to be used with Flux.jl.

CPC, triplet loss and magnet loss for multi-instance learning. For use with Flux.jl and Mill.jl.

Wrapper around the Tensorflow C api.

A wrapper around TensorFlow, a popular open source machine learning framework from Google.

EvoLP is a playground for evolutionary computation in Julia. It provides a set of predefined building blocks that can be coupled together to play around: quickly generate evolutionary computation solvers and compute statistics for a variety of optimisation tasks, including discrete, continuous and combinatorial optimisation.

Implementation of Mask RCNN in Flux.jl.

Back-end support for doing statistical inference with any model that can described as a "partially observed" (discrete) Markov chain, such as a Hidden Markov Model.

Basic simulation / parameter estimation / latent state inference for hidden Markov models. Thin front-end package built on top of DynamicDiscreteModels.jl.

Strada is a Deep Learning library for Julia, based on the popular Caffe framework developed by BVLC and the Berkeley computer vision community. It supports convolutional and recurrent neural netwok training, both on the CPU and GPU.

ArviZ.jl (pronounced "AR-vees") is a Julia package for exploratory analysis of Bayesian models. It includes functions for posterior analysis, model checking, comparison and diagnostics.

This package provides access to the classic MNIST data set of handwritten digits that has been used as a testbed for new machine learning methods.

A package for Multiple-criteria decision-making techniques in Julia.

Julia wrapper to Daniel Muellner's fastcluster library for hierarchical clustering.

A Julia implementation of boosted trees with CPU and GPU support. Efficient histogram based algorithms with support for multiple loss functions (notably multi-target objectives such as max likelihood methods).

Differentiable tree-based models for tabular data.

This repo provides Julia based benchmarks for ML algo on tabular data. It was developed to support both NeuroTreeModels.jl and EvoTrees.jl projects.

A Julia package for building production-ready measures (metrics) for statistics and machine learning.

Measures (metrics) for statistics and machine learning.

A package providing integration of OpenML with the MLJ machine learning framework.

Package providing K-nearest neighbor regressors and classifiers, for use with the MLJ machine learning framework.

MLJParticleSwarmOptimization.jl

Particle swarm optimization for hyperparameter tuning in MLJ.

A Plot recipe for plotting (decision) trees.

A small package for applying early stopping criteria to loss-generating iterative algorithms, with a view to training and optimizing machine learning models.

A lightweight package for controlling iterative algorithms, with a view to training and optimizing machine learning models.

Julia implementation of Decision Tree (CART) and Random Forest algorithms.

Julia interface to CatBoost. This library is a wrapper CatBoost's Python package via PythonCall.jl.

A package to create bagged homogeneous ensembles of machine learning models using the MLJ machine learning framework.

A package for wrapping iterative models provided by the MLJ machine learning framework in a control strategy.

Hyperparameter optimization for MLJ machine learning models.

A package providing composite models wrapping class imbalance algorithms from Imbalance.jl with classifiers from MLJ.

Repository housing feature selection algorithms for use with the machine learning toolbox MLJ.

Package for applying integration tests to models implementing the MLJ model interface.

An MLJ extension providing tools and models for text analysis.

Julia client for MLFlow.

A light-weight interface for developers wanting to integrate machine learning models into MLJ.

Repository implementing MLJ interface for NaiveBayes models.

MLJMultivariateStatsInterface.jl

Repository implementing MLJ interface for MultivariateStats models.

Repository implementing the MLJ model interface for models provided by TSVD.jl.

Repository implementing MLJ interface for LIBSVM models.

Package for testing an implementation of the MLJ model interface.

Repository implementing MLJ interface for GLM models.

This is a package gathering functionalities to solve a number of generalised linear regression/classification problems.

Repository implementing MLJ interface for XGBoost models.

Repository implementing the MLJ model interface for DecisionTree models.

Repository implementing MLJ interface for Clustering.jl models.

Repository implementing MLJ interface for scikit-learn models (via PythonCall.jl).

A Julia package with resampling methods to correct for class imbalance in a wide variety of classification settings.

Probability distributions and measures for finite sample spaces whose elements are labeled (consist of the class pool of a `CategoricalArray`

).

A lightweight wrapper of the amazing spaCy Python package.

This is a pure Julia implementation of FFTs, with the goal that this could supplant other FFTs for applications that require odd Julia objects.

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.

WorldVocoder.jl is a wrapper package for the WORLD vocoder by mmorise https://github.com/mmorise/World. It calls the original WORLD binary via the WORLD_jll.jl package.

Implementation of the 1D Savitzky-Golay filter.

Flexible filtering and smoothing in Julia. Kalman uses `DynamicIterators`

(an iterator protocol for dynamic data dependent and controlled processes) and `GaussianDistributions`

(Gaussian distributions as abstraction for the uncertain state) to implement flexible online Kalman filtering.

Directional statistics package for Julia. Currently includes several circular and spatial descriptive statistics.

File IO and signal processing tools for raw Magnetic Resonance data, with a focus on spectroscopy.

SignalBase defines a basic API to inspect signals that are regularly sampled in time. It consists of the following functions.

SignalOperators is a Julia package that aims to provide a clean interface for generating and manipulating signals: typically sounds, but any signal regularly sampled in time can be manipulated.

While a few great signal processing packages (e.g. DSP.jl, SignalOperators.jl) are available, they have limited time-frequency analysis, sonar analysis, and baseband analysis capabilities. This SignalAnalysis.jl package aims to fill that gap. The package has grown out of my research needs, but I hope to expand it over time to provide a wide variety of time-frequency analysis, and baseband signal processing tools.

Oscilloscope view from various real-time signal sources.

Julia toolbox for underwater acoustic modeling.

This package provides a Julia wrapper to the OALIB acoustic propagation modeling toolbox, making it available for use with UnderwaterAcoustics.jl.

RaySolver is a differentiable 2½D Gaussian beam tracer for use with UnderwaterAcoustics.jl. It is similar to Bellhop, but fully written in Julia to be compatible with automatic differentiation (AD) tool such as ForwardDiff (compatibility with other AD packages such as ReverseDiff and Zygote is not fully tested).

Acoustic annotations database.

This package is built upon the ideas discussed in our journal paper "Data-Aided Underwater Acoustic Ray Propagation Modeling" published on IEEE Journal of Oceanic Engineering (available online: https://ieeexplore.ieee.org/abstract/document/10224658).

ARL Julia Toolkit.

Julia UnetSocket API to connect to UnetStack.

An implementation of the Wigner-Ville transform in Julia.

Port of Richard Schreier's Delta Sigma Toolbox (https://www.mathworks.com/matlabcentral/fileexchange/19-delta-sigma-toolbox).

Process measurement/simulation results from parametric analyses.

An opinionated layer on top of FFTW.jl to provide simpler FFTs for everyone.

FourierAnalysis is a signal-processing Julia package for performing the analysis of real multivariate data (e.g., multivariate time series) in the frequency domain and in the time-frequency domain. It is based upon the DSP.jl, FFTW.jl and AbstractFFTs.jl packages.

This is a package for linear-phase FIR filter design using weighted least-squares, written in Julia.

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.

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.

The Julia wrapper for Open Source Computer Vision library (OpenCV).

High-level GUI.

Image file reading and writing.

Image processing.

Media I/O.

OpenCV library dependencies.

OpenCV Core functionality.

Currently only supports loading YOLOv2-tiny and the VOC-2007 pretrained model (pretrained on Darknet).

Wrapper for https://github.com/AlexeyAB/darknet based on pre-build binaries.

Object detection via YOLO in Julia. YOLO models are loaded directly from Darknet .cfg and .weights files as Flux models. Uses CUDA, if available.

FaceDetection using Viola-Jones' Robust Algorithm for Object Detection.

Fast kernel/stencil operations in Julia.

This provides a Julia wrapper around the Advanced Normalization Tools image registration and motion correction suite.

Memory-efficient spatial filtering of image time slices.

JpegGlitcher only exports the `glitch`

function. `glitch`

takes an image, compresses it using the JPEG encoding, safely modifies some bytes of the compressed version and return the decoded version.

Combine CoherentNoise.jl and ImageTransformations.jl to produce interesting effects on photos.

Chaotic image processing tool.

A comprehensive suite of coherent noise algorithms and composable tools for manipulating them.

Judge the image sharpness of at a certain file path location.

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

Statistical bootstrapping library for Julia.

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.

A Julia package for non-negative matrix factorization (NMF).

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.

A Julia package for performing survival analysis.

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.

LowRankModels.jl is a Julia package for modeling and fitting generalized low rank models (GLRMs). GLRMs model a data array by a low rank matrix, and include many well known models in data analysis, such as principal components analysis (PCA), matrix completion, robust PCA, nonnegative matrix factorization, k-means, and many more.

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 package defines the basic types and interface for OnlineStats.

Online estimate of the median by variational/Bayesian methods.

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.

A package for implementing Instantaneous Linear Mixing Models (ILMMs) and Orthogonal Instantaneous Linear Mixing Models (OILMMs) using the AbstractGPs interface.

KeyedDistributions.jl provides thin wrappers of Distribution and Sampleable, to store keys and dimnames for the variates.

TrackedDistributions extends Distributions such that it can work with TrackedArrays.

This package defines robust linear models using the interfaces from StatsBase.jl and StatsModels.jl. It defines an `AbstractRobustModel`

type as a subtype of `RegressionModel`

and it defines the methods from the statistical model API like `fit`

/`fit!`

.

Roll a [weighted] function or run a statistic along windowed data.

Support for incremental statistics.

A more capable `RollingFunctions.jl`

.

Successor to RollingFunctions.jl.

Performant accumulators that accept each [k] successive value[s] from a data stream.

Use adjacent bits as a named bitfield. Use multiple bitfields in distinct roles or as primary elements.

Stemplots in Julia.

Online Algorithms for Statistics, Models, and Big Data Viz.

Tools for analyzing the power of proposed statistical designs.

This package provides publication-quality regression tables for use with FixedEffectModels.jl and GLM.jl, as well as any package that implements the RegressionModel abstraction.

Julia wrapper to Daniel Muellner's fastcluster library for hierarchical clustering.

Julia wrapper for the alpaca R library to estimate generalized linear model with high-dimensional fixed effects.

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

Coefplots aims to make available in Julia (part of) the functionalities of the Stata command coefplot. Coefplots is built on PGFPlotsX.

This package estimates generalized linear models with high dimensional categorical variables. It builds on Matthieu Gomez's FixedEffects.jl, Amrei Stammann's Alpaca, and Sergio Correia's ppmlhdfe.

This package should be used as a backend by package developers. It allows developers to add a `::CovarianceEstimator`

argument in the `fit`

method defined by their package.

This package estimates linear models with high dimensional categorical variables and/or instrumental variables.

This package solves least squares problem with high dimensional fixed effects. For a matrix `D`

of high dimensional fixed effects, it finds `b`

and `ϵ`

such that `y = D'b + ϵ`

with `E[Dϵ] = 0`

. It is the back end for the package FixedEffectModels.jl, that estimates linear models with high-dimensional fixed effect.

InteractiveFixedEffectModels.jl

This package implements a novel, fast and robust algorithm to estimate interactive fixed effect models.

The RDatasets package provides an easy way for Julia users to experiment with most of the standard data sets that are available in the core of R as well as datasets included with many of R's most popular packages. This package is essentially a simplistic port of the Rdatasets repo created by Vincent Arelbundock, who conveniently gathered data sets from many of the standard R packages in one convenient location on GitHub at https://github.com/vincentarelbundock/Rdatasets

Bayesian inference with probabilistic programming.

Alpha stable and sub-Gaussian distributions in Julia.

StateSpaceModels.jl is a package for modeling, forecasting, and simulating time series in a state-space framework. Implementations were made based on the book "Time Series Analysis by State Space Methods" (2012) by James Durbin and Siem Jan Koopman. The notation of the variables in the code also follows the book.

Simple ANOVA In Julia.

Basic two way ANOVA and repeated measures ANOVA in Julia.

One-way ANOVA: `ANOVA.anova`

, two-way ANOVA: `ANOVA.anova2`

, one-way repeated measures ANOVA: `ANOVA.rm_anova`

, two-way repeated measures ANOVA: `ANOVA.rm_anova2`

.

Analysis of Variance for Julia, the old-fashioned way.

Quality and Process improvement from Minitab.

AnovaBase.jl is a Julia package providing a simple framework for Analysis of Variance (ANOVA) on various types of Julia statistical models. It is similar to function ANOVA in R.

Conduct one-way and multi-way ANOVA in Julia with MixedModels.jl

Conduct one-way and multi-way ANOVA in Julia with FixedEffectModels.jl

Conduct one-way and multi-way ANOVA in Julia with GLM.jl

Calculate ANOVA tables for linear models. If no `anovatype`

argument is provided, a type III ANOVA will be calculated. Type I and II are also supported for compatibility. Support for mixed models and a more convenient way to create ANOVAs (similar to the ez package in R) is planned.

LongMemory.jl is a package for time series long memory modelling in Julia.

Diagonalization procedures for Julia (PCA, Whitening, MCA, gMCA, CCA, gCCA, CSP, CSTP, AJD, mAJD).

A julia package for working with Measurement Error Models. This package was developed to calibrate Measurement Error Proxy System Models (MEPSMs).

Linear and nonlinear predictable components from multivariate data.

This package defines robust linear models using the interfaces from StatsBase.jl and StatsModels.jl. It defines an AbstractRobustModel type as a subtype of RegressionModel and it defines the methods from the statistical model API like `fit`

/`fit!`

.

LinearRegressionKit.jl implements linear regression using the least-squares algorithm (relying on the sweep operator). This package is in the beta stage. Hence it is likely that some bugs exist. Furthermore, the API might change in future versions.

This package provides publication-quality regression tables for use with FixedEffectModels.jl, GLM.jl, GLFixedEffectModels.jl and MixedModels.jl, as well as any package that implements the RegressionModel abstraction.

A Julia package for Bayesian optimal experimental design with nonlinear regression models.

Julia package for similarity detection by Locality-Sensitive MinHash.

EffectSizes.jl is a Julia package for effect size measures. Confidence intervals are assigned to effect sizes using the Normal distribution or by bootstrap resampling.

This package is a Julia replication of the Stata package `eventstudyinteract`

.

Linear combinations of parameters for FixedEffectModels.jl and EventStudyInteracts.jl like Stata package `lincom`

.

MannKendall.jl is a pure julia package for Mann-Kendall trend test.

Pingouin is designed for users who want simple yet exhaustive stats functions.

This package aim is to implement in Julia some robust mean estimators (one-dimensional for now).

A Julia package for outlier detection in linear regression.

Extended StatsModels.jl `@formula`

syntax for regression modeling.

Lathe.jl is an all-in-one package for predictive modeling in Julia. It comes packaged with a Stats Library, Preprocessing Tools, Distributions, Machine-Learning Models, and Model Validation.

MixedLRMoE.jl is an implementation of the Mixed Logit-Reduced Mixture-of-Experts (Mixed LRMoE) model in julia.

Effects Prediction for Linear and Generalized Linear models.

A Gaussian Processes package for Julia.

A fast and flexible Structural Equation Modelling Framework.

Automatic differentiation support for structural equation models.

Relies on StructuralEquationModels.jl to implement SNLLS (= separable nonlinear least squares) estimation of structural equation models. For more background, see https://psyarxiv.com/b6uxm/.

This is a package for regularized structural equation modeling. It connects StructuralEquationModels.jl to ProximalAlgorithms.jl.

Low-level interface for sparse regression.

Statisticians often work with standardized matrices. If x is a data matrix with observations in rows, we want to work with `z = StatsBase.zscore(x, 1)`

. This package defines a `StandardizedMatrix`

type that treats a matrix as standardized without copying or changing data in place.

Experiments using MM algorithms for regularized generalized linear models.

Experimental changes to SparseRegression.jl.

Simple visualizations of correlation matrices.

Generate data for generalized linear models and more.

Reproducible.jl is a lightweight package for creating reproducible reports in Julia.

Parse Statistical Formulas into Feature Columns.

Julia wrapper for the gtrendsR package.

Statistical Models with Regularization in Pure Julia.

High-performance Generalized LS solvers.

NISTStatisticalReferenceData.jl

This package provides utilities for working with the datasets and certified values provided by NIST's Statistical Reference Datasets (StRD).

The symmetric sweep operator is a powerful tool in computational statistics with uses in stepwise regression, conditional multivariate normal distributions, MANOVA, and more.

An Averaged Shifted Histogram (ASH) is essentially Kernel Density Estimation over a fine-partition histogram. ASH uses constant memory, can be constructed on-line via O(nbins) updates, and lets you estimate densities for arbitrarily big data.

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

Process EEG files in Julia.

Miscellaneous Julia utilities for psychophysics research.

This package implements efficient multitaper and continuous wavelet transforms, along with the following transform statistics most of which operate on pairs of signals: Power spectral density (PowerSpectrum), Power spectral density variance (PowerSpectrumVariance), Cross spectrum (CrossSpectrum), Coherence (Coherence for the absolute value, Coherency for the complex value), Phase locking value, a.k.a. the mean resultant vector length or R̄ (PLV), Pairwise phase consistency, a.k.a. the unbiased estimator of R̄^2 (PPC), Phase lag index (PLI), Unbiased squared phase lang index (PLI2Unbiased), Weighted phase lag index (WPLI), Debiased squared weighted phase lag index (WPLI2Debiased), Jammalamadaka circular correlation coefficient (JCircularCorrelation), Jupp-Mardia squared circular correlation coefficient (JMCircularCorrelation), Hurtado et al. modulation index (phase-amplitude coupling) (HurtadoModulationIndex). Additionally, the following point-field measures are implemented: Point-field coherence (pfcoherence), Point-field PLV (pfplv), Point-field PPC, variants 0, 1, and 2 (pfppc0, pfppc1, pfppc2). And the following point-point measures: Point-point cross correlation (pfxcorr).

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.

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

Toolbox for analyzing neurophysiological data with Julia.

Toolbox to perform linear regression on biological signals.

A package to simulate single timeseries model-based ERPs, fMRI activity, pupil dilation etc. If you have one channel, it is a timeseries of (overlapping) event-related activity and some noise - you might have fun here!

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

Fast implementation of the ClusterDepth multiple comparison algorithm from Frossard and Renaud Neuroimage 2022. This is especially interesting to EEG signals. Currently only acts on a single channel/timeseries. Multichannel as discussed in the paper is the next step.

HeartBeats.jl provides a heartbeat detector based on the approach described by Pan & Tompkins (1985).

XDF.jl is an importer for XDF files written in Julia.

Tools to import LSL/XDF Data.

Accessing and analyzing data from the Allen Brain Atlas.

Core properties for interacting with neuroscience data in Julia.

Graph theory for neuroscience data.

Package for organizing neuroscience studies. Design is highly motivated by the Brain Imaging Data Structure (BIDS) specification.

Julia Spiking Neural Network Simulator.

Julia has enough tools to support fitting spiking neural network models to data. Python speed necessitates external simulators to do network simulation. As much as possible it would be nice to do fast, efficient data fitting of spike trains to network models in one language, lets try to do that here.

Julia implementations for measuring distances, synchrony and correlation between spike trains.

Weber is a Julia package that can be used to generate simple psychology experiments that present visual and auditory stimuli at precise times.

This Julia package extends Weber, to allow triggers to be sent during EEG recording using the DAQmx api. It is a simple extension which translates the `record`

codes, during a call to record, to digital trigger events.

This Julia package extends Weber, to enable the use of Cedrus response-pad input. It adds a series of new keys, ranging from `key":cedrus0:"`

to `key":cedrus19:"`

. You can see which key is which by pressing the buttons while running the following code in julia.

WebIO provides a simple abstraction for displaying and interacting with web content.

Meta package for Genie reactive apps.

Genie is a full-stack web framework that provides a streamlined and efficient workflow for developing modern web applications. It builds on Julia's strengths (high-level, high-performance, dynamic, JIT compiled), exposing a rich API and a powerful toolset for productive web development.

Higher level UI elements for Genie apps.

GenieAutoReload monitors the indicated files and folders (recursively) and automatically recompiles the Julia code and reloads the corresponding browser window.

Package Management solution for Genie.jl and GenieBuilder Apps.

Genie plugin providing functionality for creating and working with Genie plugins.

Authentication plugin for Genie.jl.

Role Based Authorisation (RBA) plugin for Genie.jl.

Abstract package for Genie caching.

Sessions support for Genie apps.

File system based session adapter for GenieSession.jl.

File system cache adapter for GenieCache.jl.

GenieDevTools.

GenieDeploy.

GenieDeployHeroku.

GenieDeployJuliaHub.

Genie on Docker.

SearchLight is the ORM layer of Genie.jl, the high-performance high-productivity Julia web framework.

JSON data serializer for SearchLight.

SQLite adapter for SearchLight.

Postgres adapter for SearchLight.

MySQL adapter for SearchLight.

The project fullfills the API of SearchLight. The adpater can be used for communicating with Oracle databases.

Stipple is a reactive UI library for building interactive data applications in pure Julia. It uses Genie.jl (on the server side) and Vue.js (on the client). Stipple uses a high performance MVVM architecture, which automatically synchronizes the state two-way (server -> client and client -> server) sending only JSON data over the wire. The Stipple package provides the fundamental communication layer, extending Genie's HTML API with a reactive component.

StippleUI is a library of reactive UI elements for Stipple.jl.

StippleCharts is a library of reactive charts for Stipple.jl.

Embedding Plotly Charts in Stipple.

StipplePlotlyExport.

StippleLatex.

Want to use Swagger UI in Julia? This package has your back!

Swagger Markdown allows you to generate swagger.json for API documentation from the julia source code. The package uses marco to process the markdown that contains an API endpoint's documentation. The markdowon needs to follow the paths described by the OpenAPI Specification (v3, v2), and in YAML format.

Franklin is a simple static site generator (SSG) oriented towards technical blogging (code, maths, ...), flexibility and extensibility. The base syntax is plain markdown with a few extensions such as the ability to define and use LaTeX-like commands in or outside of maths environments and the possibility to evaluate code blocks on the fly.

Templates for Franklin, the static-site generator in Julia. Most of these templates are adapted from existing, popular templates with minor modifications to accommodate Franklin's content.

Mux.jl gives your Julia web services some closure. Mux allows you to define servers in terms of highly modular and composable components called middleware, with the aim of making both simple and complex servers as simple as possible to throw together.

A wrapper for Tachyons CSS framework.

A Julia wrapper for Vue.js. It uses WebIO to load JavaScript and to do Julia to JS communication.

A Julia wrapper for Knockout.js. It uses WebIO to load JavaScript and to do Julia to JS communication.

This is a simple and lightweight development web-server written in Julia, based on HTTP.jl. It has live-reload capability, i.e. when modifying a file, every browser (tab) currently displaying the corresponding page is automatically refreshed.

Julia wrapper for libCURL.

Oxygen is a micro-framework built on top of the HTTP.jl library. Breathe easy knowing you can quickly spin up a web server with abstractions you're already familiar with.

A flexible, powerful, high level interface for Websockets in Julia. Provides a SERVER and CLIENT.

WebAssets provides a simple API for managing local versions of files based on URLs.

Using Julia to write https://htmx.org

Use the TailwindCSS CLI from Julia.

A tool to setup `ssh-agent`

.

A Julia FTP client using LibCURL supporting FTP and FTP over SSL.

A Julia interface for running a test FTP server with pyftpdlib.

A light-weight high-performance UDP sockets library.

A CURL based SMTP client with fairly low level API. It is useful for sending emails from within Julia code. Depends on LibCURL.jl.

This is a Julia package to read and write the WAV audio file format.

PortAudio.jl is a wrapper for libportaudio, which gives cross-platform access to audio devices. It is compatible with the types defined in SampledSignals.jl. It provides a `PortAudioStream`

type, which can be read from and written to.

SampledSignals is a collection of types intended to be used on multichannel sampled signals like audio or radio data, EEG signals, etc., to provide better interoperability between packages that read data from files or streams, DSP packages, and output and display packages.

LibSndFile.jl is a wrapper for libsndfile, and supports a wide variety of file and sample formats. The package uses the FileIO `load`

and `save`

interface to automatically figure out the file type of the file to be opened, and the file contents are represented as a `SampleBuf`

. For streaming I/O we support FileIO's `loadstreaming`

and `savestreaming`

functions as well. The results are represented as `SampleSource`

(for reading), or `SampleSink`

(for writing) subtypes. These buffer and stream types are defined in the SampledSignals package.

This package provides the `RingBuffer`

type, which is a circular, fixed-size multi-channel buffer.

MIDI.jl is a complete Julia package for reading and writing MIDI data.

Mplay is a full functional MIDI player written in pure Julia. It reads Standard MIDI Files (SMF) and sends them to MIDI devices (or software synthesizers) while giving visual feedback.

AudioSchedules allows you to schedule a sequence of overlapping audio synthesizers. Critically, it allows you to do this without lags or gaps.

MusicProcessing.jl is a music and audio processing library for Julia, inspired by librosa. It is not feature complete and in a very early stage of development.

Providing music-related visualization built on top of the packages of JuliaMusic.

Manipulate music data (translate/transpose etc). Advanced music data extraction. Quantize/classify notes. Take your music practice to the next level. And more!

Powerful MusicXML reading and writing package for Julia.

PianoFingering.jl is an automatic fingering generator for piano scores, written in the Julia language.

GMT is a toolbox for Earth, Ocean, and Planetary Science. Besides its own map projections implementation and mapping capabilities it wraps the GDAL library which gives access to most of of raster and vector formats used in geospatial world.

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.

GDAL is a translator library for raster and vector geospatial data formats that is released under an X/MIT license by the Open Source Geospatial Foundation. As a library, it presents an abstract data model to drivers for various raster and vector formats.

This package provides basic functionality for parsing, viewing, and working with OpenStreetMap map data. The package is intended mainly for researchers who want to incorporate this rich, global data into their work, and has been designed with both speed and simplicity in mind, especially for those who might be new to Julia.

A spatial analysis library written in Julia, ported from the great Turf.js.

Simple geographical vector interaction built on top of ArchGDAL. Inspiration from geopandas.

Circuitscape is an open-source program that uses circuit theory to model connectivity in heterogeneous landscapes. Its most common applications include modeling movement and gene flow of plants and animals, as well as identifying areas important for connectivity conservation.

This library brings the Google Maps API Web Services to Julia, and supports the following Google Maps APIs: Directions API, Geocoding API, Places API, Roads API.

Julia package to create kepler.gl-compatible maps, to be rendered using one of the following Julia frontends: KeplerGL.jl and StippleKeplerGL.jl.

Julia package to create, render, and export geospatial maps, using Kepler.gl, via Blink.jl.

Julia package to integrate KeplerGL maps into Genie/Stipple applications.

A Julia Framework for Quantum Dynamics and Control.

Common types and methods for the JuliaQuantumControl organization.

Methods for simulating the time dynamics of a quantum system for packages with the JuliaQuantumControl organization.

Dynamic Gradients for Quantum Control.

Implementation of Krotov's method of optimal control enhanced with automatic differentiation.

Implementation of (second-order) GRadient Ascent Pulse Engineering (GRAPE) extended with automatic differentiation.

A package to analyze and debug LBFGS linesearch behavior inside GRAPE.jl.

Library for solving quantum optimal control problems in Julia. Currently offers support for GRAPE and dCRAB algorithms using piecewise constant controls.

Julia package for analyzing two-qubit gates in the Weyl chamber.

QuantumOpticsControlExtensions.jl

This package extends methods from QuantumPropagator.jl and QuantumControl.jl for types defined in QuantumOptics.jl.

This package is a Julia implementation of the Amazon Braket SDK allowing customers to access Quantum Hardware and Simulators.

The Quantica.jl package provides an expressive API to build arbitrary quantum systems on a discrete lattice, and a collection of algorithms to compute some of their properties.

IANA time zone database access for the Julia programming language. TimeZones.jl extends the Date/DateTime support for Julia to include a new time zone aware TimeType: ZonedDateTime.

TZJData provides releases of the IANA tzdata compiled into the tzjfile (time zone julia file) format. The compiled data stored via package artifacts and used by the TimeZones.jl as an the source of pre-computed time zones.

Dates with nanosecond resolved days.

A new minor version of this package will be published everytime a new leap second is issued be the IERS and dependent packages will need to be updated!

Provides `LaxZonedDateTime`

, an alternative to TimeZones.jl's `ZonedDateTime`

that does not raise exceptions when a time that is ambiguous or doesn't exist is encountered.

Julia library for handling holidays.

UTCDateTime is a very simple time zone aware datetime representation that is always in the UTC time zone.

Universal Time and Local Time with a great deal of care in how libc is used.

Enhances Dates.CompoundPeriod.

Provides TimeDate, a nanosecond resolved DateTime type.

`TimeDate`

is nanosecond resolved, and `DateTime`

compatible.

DateNano is a nanosecond resolved DateTime type.

Experimental Dates stdlib to support TimesDates.jl v2.

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.

This is a Julia module for calculating Cyclic Redundancy Checksums (CRCs).

CRC32 is a Julia package for computing the CRC-32 checksum as defined by the ISO 3309 / ITU-T V.42 / CRC-32-IEEE standards, designed as a drop-in replacement for Julia's CRC32c standard library (which computes the CRC-32c checksum).

A pure julia MD5 implementation. There is few reasons to create new MD5 checksums, but there are a huge number of existing ones. Honestly, just use SHA-256 for everything you would use MD5 for. MD5 is not secure, and it's not faster, and it doesn't have much going for it.

A performant, 100% native-julia SHA1, SHA2, and SHA3 implementation.

A futuristic crypto library. In Julia.

Toy implementation of FHE algorithms.

Generates the SSH keys that are required for the automatic deployment of documentation with Documenter from a builder to GitHub Pages.

Pure Julia implementation of the Ripemd hashing algorithm. Currently only Ripemd160 is implemented and convenience functions are missing.

SEAL.jl is a Julia package that wraps the Microsoft SEAL library for homomorphic encryption. It supports the Brakerski/Fan-Vercauteren (BFV) and Cheon-Kim-Kim-Song (CKKS, also known as HEAAN in literature) schemes and exposes the homomorphic encryption capabilitites of SEAL in a (mostly) intuitive and Julian way. SEAL.jl is published under the same permissive MIT license as the Microsoft SEAL library.

Julia wrapper around nettle cryptographic hashing/encryption library providing MD5, SHA1, SHA2 hashing and HMAC functionality, as well as AES encryption/decryption.

Provides `YearMonth`

type for the Julia language.

Let's calculate Pi using a very inefficient Monte-Carlo simulation.

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 high-performance geostatistics in Julia.

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

TermWin.jl is a tool to help navigate tree-like data structure such as Expr, Dict, Array, Module, and DataFrame It uses a ncurses-based user interface. It also contains a backend framework for composing ncurses user interfaces.

This package wraps the C library ncurses and provide a Julia-like API to build text user interfaces. The development was highly based on the package TermWin.jl.

Create TerminalUserInterfaces in Julia.

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).

This module provides an open source suite for generating synthetic grids based on real data openly available to the public.

A supplemental power systems units package for Unitful 0.15.0 or later.

The goal of the package is to provide functions that take a power grid as input, vary its parameters and generate feasible DC- and AC-OPF samples along with the corresponding solutions. This helps the user to explore a variety of distinct active sets of constraints of synthetic cases and mimic the time-varying behaviour of the OPF input parameters.

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.

SenseHat.jl is a Julia library for interacting with the Raspberry Pi Sense HAT.

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.

Utility module for working with grammatical rules (singular, plural, underscores, etc).

A Julia module to generate random sequences of motifs, under the constrain that the sequence has some given total length.

ThinFilmsTools.jl provides tools for the design and characterisation of thin films written in Julia.

Registry of gain conversions for scientific cameras.

Infrastructure for handling physical units for the Julia programming language.Registry of gain conversions for scientific cameras.

VT100.jl attempts to implement a small and hackable terminal emulator, mostly intended for automatic verification of Terminal based UIs. The current implementation is very simple and ignores most of the more complicated ascepts of terminal emulation, including colors, attributes and Unicode combining characters, but is nevertheless useful for UI validation in regression tests. Support for those features will be added as the need arises.

A simple Julia wrapper for Tesseract OCR.

BioAlignments.jl provides sequence alignment algorithms and data structures.

MolecularGraph.jl is a graph-based molecule modeling and chemoinformatics analysis toolkit fully implemented in Julia.

This package supports limited plotting of mass spectrometry data. It is designed to be format-agnostic through its use of the MzCore interface, although currently only MzXML has been implemented.

MzCore defines traits and utilities for mass spectrometry analyses in Julia. The primary purpose is to allow algorithms to be written in a manner that is independent of the representation used for specific file formats.

This package provides a julia wrapper to the Blossom V software package which provides an implementation of a minimum cost perfect matching algorithm.

Humanize numbers: data sizes, datetime deltas, digit separators.

Fast string implementation inspired by SpiderMonkey.

Represent modular arithmetic via clock symbols.

A Julia version of the Python Gin configuration library.

Wrapper around the open-source components of Graphlab.

GraphQL server for Julia.

WaterLily.jl is a simple and fast fluid simulator written in pure Julia. This is an experimental project to take advantage of the active scientific community in Julia to accelerate and enhance fluid simulations.

Voxel Simulator written using Makie's GLMakie backend in Julia.

This project is a wrapping of Raylib, which is a simple and easy-to-use library to enjoy videogames programming.

In a nutshell, this package is meant to generate books (or reports or dashboards) with embedded Julia output. Via Pandoc, the package can live serve a website and build various outputs including a website and PDF. For many standard output types, such as DataFrames and plots, the package can run your code and will automatically handle proper embedding in the output documents, and also try to guess suitable captions and labels. Also, it is possible to work via the live server, which shows changes within seconds.

A Brainfuck interpreter written in Julia. Because `<-->`

.

Common unicode aliases for Julia.

WatchJuliaBurn aims at destroying the look of your code by adding emojis like 😄 and kaomojis like c╯°□°ↄ╯ instead of your favorite Julia functions. For a serious use of unicode characters see also Ueauty.jl

Alert provides a cross-platform means of displaying a notification to the user in Julia. It should work on MacOS, Windows 10 (even under WSL2) and many flavors of Linux.

AlertPushover provides a backend for Alert. It uses the Pushover service to send notifications remotely to the Pushover app. This makes alert useful even when working remotely or via an online IDE.

Automatic identify sphingolipids through PreIS and MRM.

Predict and match digested peptides sequences, their mass m/z and MS/MS spectra with chemical derivatization or post-translational modification.

This is a simple package for processing post-column infusion internal standard(PCIIS) data on dried blood spot(DBS) sample for volume detection.

Implementation of various tree and heaps structures.

`@pip`

and `@pipas`

enable R's `%>%`

and `%<>%`

syntax. Arguments are seperated by space. Broadcasting and anonymous functions are supported; however, `@pipas`

can only assign global variable.

Fine control over numeric output: Scientific/Engineering/SI-notation.

VectorizedRoutines.jl provides a library of familiar and useful vectorized routines. This package hopes to include high-performance, tested, and documented Julia implementations of routines which MATLAB/Python/R users would be familiar with. We also welcome generally useful routines for operating on vectors/arrays.

A lightweight package delivering utility functions for working with multi-dimensional data. It provides efficient versions to deal with sizes, midpoints etc. of multidimensional data.

A Julia package for working with spacetime field (stfield) objects. An stfield object is a data field with data, longitude, latitude, time.

A Julia package for working with coupled fields. This is work in progress. The main function `gradvecfield`

calculates the gradient vector or gradient matrix for each instance of the coupled fields.

Shear Optimization with ShOpt.jl, a julia library for empirical point spread function characterizations.

Lints.jl provides an interface to the Libint2 molecular integral generation library.

Handling of molecular symmetry, including character table generation and SALCs.

This package offers tools to create and manipulate atomic ensamble for molecular simulations.

GaussianBasis offers high-level utilities for molecular integral computations.

Julia wrapper for TBLIS tensor contraction library.

TensorOperations.jl compatible fast contractor for Julia, based on TBLIS, with generic strides and automatic differentiation support.

Fermi.jl is a quantum chemistry framework written in pure Julia. This code is developed at the Center for Computational Quantum Chemistry at the University of Georgia under the supervision of Dr. Justin M. Turney and Prof. Henry F. Schaefer.

This package provides access to the https://heroicons.com collection of SVG icons from Julia.

A Julia package for retrieving data from the XKCD webcomic: xkcd.com.

Find the index of (sorted) collection that has the smallest distance to x.

Bakshi T. Tanmay Teaches Julia for Beginners: A Springboard to Machine Learning for All Ages. ISBN: 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: 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, Downey A. 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

Bezanzon J, Chen J, Chung B, Karpinski S, Shah V, Zoubritzky L, Vitek J. Julia: Dynamism and Performance Reconciled by Design. PDF

Belyakova J, Chung B, Gelinas J, Nash J, Tate R, Vitek J. World Age in Julia. PDF

Chung B, Nardelli F, Vitek J. Julia's efficient algorithm for subtyping unions and covariant tuples. PDF

Pelenitsyn A, Belyakova J, Chung B, Tate R, Vitek J. Type Stability in Julia. PDF

Kochenderfer M, and Wheeler T. Algorithms for optimization. ISBN: 9780262039420 PDF

Boyd S, Vandenberghe L. Convex Optimization. ISBN: 0521833787 PDF

Kwon C. Julia Programming for Operations Research. ISBN: 1798205475 HTML

Lusby R, Stidsen T. Mathematical Programming with Julia. ISBN: 9788793458253 PDF

Schoen F. Optimization Models. HTML

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: 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

Storopoli J. Bayesian Statistics with Julia and Turing

Lukaszuk B. Romeo and Julia, where Romeo is Basic Statistics

Voulgaris Z. Julia for Machine Learning. ISBN: 9781634628136

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.

Perkel J. Julia: come for the syntax, stay for the speed. Nature 572, 2019: 141-142. DOI: 10.1038/d41586-019-02310-3

Geospatial Data Science with Julia

Geospatial Data Science with Julia presents a fresh approach to data science with geospatial data and the Julia programming language. It contains best practices for writing clean, readable and performant code in geoscientific applications involving sophisticated representations of the (sub)surface of the Earth such as unstructured meshes made of 2D and 3D geometries.

The Julia Presentation – presented in 2023.12.01 at Istanbul University, Faculty of Economics

Julia MixedModels.jl workshop @ MindCORE

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 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.

A gallery of easy to copy-paste examples.

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

The ultimate guide to distributed computing

Denoising diffusion probabilistic models from first principles

A quick introduction to data parallelism in Julia

Distributed computing with Julia

The ultimate guide to distributed computing in Julia

A brief tutorial on training a Neural Network with Flux.jl

Introduction in deep learning with Julia

Administrative Scripting with Julia

Extreme Multi-Threading: C++ and Julia 1.9 Integration

JuLox: What I Learned Building a Lox Interpreter in Julia

Building GUIs with Julia, Tk, and Cairo, Part I

Building GUIs with Julia, Tk, and Cairo, Part II

Hiccups Writing GTK3 GUI Code in Julia

An Introduction to Laplace Approximations for Bayesian Deep Learning in Julia

Data Science Tutorials in Julia

Introduction to probabilistic programming in Julia

Interactive contour maps of surface temperature anomalies in 2016

set up NeoVim + Tmux for a Data Science Workflow with Julia

Using evotrees.jl for time series prediction

Creating your own blog with Julia and Franklin

An Introduction to Structural Econometrics in Julia

Julia for Optimization and Learning

What the heck is Julia and why won't Cameron shut up about it

This document specifies style conventions for Julia code. These conventions were created from a variety of sources including Python's PEP8, Julia's Notes for Contributors, and Julia's Style Guide.

Trustworthy Artificial Intelligence in Julia

CC BY-SA 4.0 Adam Wysokiński. Last modified: September 11, 2024.

Website built with Franklin.jl and the Julia programming language.

Website built with Franklin.jl and the Julia programming language.