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

This package defines functions for getting multiple indices out of dictionaries, tuples, etc, extending this ability beyond AbstractArray.

This package supports representing banded matrices by only the entries on the bands.

CommonSolve.jl provides solve, init, solve!, and step! commands. By using the same definition, solver libraries from other completely different ecosystems can extend the functions and thus not clash with SciML if both ecosystems export the solve command.

This package supports lazy analogues of array operations like vcat, hcat, and multiplication. This helps with the implementation of matrix-free methods for iterative solvers.

This package provides macros for defining the required behaviours of Julia interfaces, and stating that an object implements them.

ReverseDiff.jl is a fast and compile-able tape-based reverse mode AD, that implements methods to take gradients, Jacobians, Hessians, and higher-order derivatives of native Julia functions (or any callable object, really).

This package enables the Julia compiler to generate efficient code when running test cases. Test cases are typically run with flags that prevent efficient code generation. This package detects those flags and instead spawns a separate Julia process without the flags in which to run the test cases.

This package aims at establishing common ground for Optim.jl, LineSearches.jl, and NLsolve.jl. The common ground is mainly the types used to hold objective related callables, information about the objectives, and an interface to interact with these types.

This package implements methods to take derivatives, gradients, Jacobians, Hessians, and higher-order derivatives of native Julia functions (or any callable object, really) using forward mode automatic differentiation (AD).

MutableArithmetics is a Julia package which allows:

• mutable types to implement mutable arithmetics

• algorithms that could exploit mutable arithmetics to exploit them while still being completely generic

This is a small package to make it easier to type LaTeX equations in string literals in the Julia language.

ItemGraphs is a simple wrapper around LightGraphs that enables most common use case for graph-like data structures: with collection of items that are in relations between each other providing the shortest path between two items.

This package provides a simple Julian API to use the libsass library to compile scss and sass files to css.

This package defines a new operator for composition of morphisms.

This package contains types with default field values, keyword constructors and (un-)pack macros. Keyword functions can be slow in Julia, however, the normal positional constructor is also provided and could be used in performance critical code.

A block array is a partition of an array into blocks or subarrays. This package has two purposes. Firstly, it defines an interface for an AbstractBlockArray block arrays that can be shared among types representing different types of block arrays. The advantage to this is that it provides a consistent API for block arrays. Secondly, it also implements two different type of block arrays that follow the AbstractBlockArray interface. The type BlockArray stores each block contiguously while the type PseudoBlockArray stores the full matrix contiguously. This means that BlockArray supports fast non copying extraction and insertion of blocks while PseudoBlockArray supports fast access to the full matrix to use in in for example a linear solver.

This minimalistic package serves as the foundation for other SIMD packages in Julia.

This package provides manually managed memory buffers backed by NTuples in Julia.

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. The real dot product is useful when one treats complex numbers as embedded in a real vector space.

libwhich is like which, but for dynamic libraries. It is also a bit like ldd and otool -L.

Julia is a high-level, high-performance dynamic programming language for technical computing, with syntax that is familiar to users of other technical computing environments. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, and an extensive mathematical function library.

Voilà turns Jupyter notebooks into standalone web applications. Unlike the usual HTML-converted notebooks, each user connecting to the Voilà tornado application gets a dedicated Jupyter kernel which can execute the callbacks to changes in Jupyter interactive widgets.

jupyter_kernel_test is a tool for testing Jupyter kernels. It tests kernels for successful code execution and conformance with the Jupyter Messaging Protocol.