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 09 April, 2024
Number of entries 1258
Created and maintained by Adam Wysokiński.
If you've contributed, add your name below:
Adam Wysokiński, jluis, uncomfyhalomacro, heltonmc
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.
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 configures 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.
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.
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, adjustcrc and adjustcrc!, 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.
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.
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.
A pure Julia implementation of the apache arrow memory format specification.
This package is about interfaces to the Dataverse project APIs, collections, datasets, etc.
Yet another JSON package for Julia; this one is for speed and slick struct mapping.
This package contains the Julia binding for the chemfiles library. It allow you, as a programmer, to read and write chemistry trajectory files easily, with the same simple interface for all the supported formats. For more information, please read the introduction to chemfiles.
A 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. Dicts). 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. LayerDicts 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 UInt8s 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.
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.
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.
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.
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 maximumflow, multirouteflow 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.
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.
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.
Online estimate of the median by variational/Bayesian methods.
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++.
A Machine Learning Framework for Julia.
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.
This package makes a distinction between machine type and scientific type of a Julia object.
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 AbstractArrays and Tables.
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.
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.
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.
Bootstrap.jl: Statistical Bootstrapping
Clustering.jl is a Julia package for data clustering.
A Julia package for evaluating distances(metrics) between vectors.
This package implements several hypothesis tests in Julia.
Kernel density estimators for Julia.
This is a pure Julia loess implementation, based on the fast kd-tree based approximation, implemented in the netlib loess C/Fortran code, and used by many, including in R's loess function.
A Julia package for multivariate statistics and data analysis (e.g. dimensionality reduction).
MixedModels.jl is a Julia package providing capabilities for fitting and examining linear and generalized linear mixed-effect models.
StatsBase.jl is a Julia package that provides basic support for statistics. Particularly, it implements a variety of statistics-related functions, such as scalar statistics, high-order moment computation, counting, ranking, covariances, sampling, and empirical density estimation.
This package provides common abstractions and utilities for specifying, fitting, and evaluating statistical models.
Mathematical functions related to statistics.
Linear and generalized linear models in Julia.
The Distributions package provides a large collection of probabilistic distributions and related functions.
The TimeSeries package provides convenient methods for working with time series data in Julia.
MultivariateStats.jl is a Julia package for multivariate statistical analysis. It provides a rich set of useful analysis techniques, such as PCA, CCA, LDA, PLS, etc.
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 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.
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.
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.
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.
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.
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. http://janvitek.org/pubs/oopsla18b.pdf
Belyakova J, Chung B, Gelinas J, Nash J, Tate R, Vitek J. World Age in Julia. http://janvitek.org/pubs/oopsla20-j.pdf
Chung B, Nardelli F, Vitek J. Julia's efficient algorithm for subtyping unions and covariant tuples. http://janvitek.org/pubs/ecoop19.pdf
Pelenitsyn A, Belyakova J, Chung B, Tate R, Vitek J. Type Stability in Julia. http://janvitek.org/pubs/oopsla21c.pdf
Kochenderfer M, and Wheeler T. Algorithms for optimization. ISBN: 9780262039420 https://algorithmsbook.com/optimization/files/optimization.pdf
Boyd S, Vandenberghe L. Convex Optimization. ISBN: 0521833787 https://web.stanford.edu/~boyd/cvxbook/bv_cvxbook.pdf
Kwon C. Julia Programming for Operations Research. ISBN: 1798205475 https://juliabook.chkwon.net/book
Lusby R, Stidsen T. Mathematical Programming with Julia. ISBN: 9788793458253 https://www.man.dtu.dk/-/media/centre/management-science/mathprogrammingwithjulia/mathematical-programming-with-julia.pdf
Schoen F. Optimization Models. https://webgol.dinfo.unifi.it/OptimizationModels/contents.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