This package allows programmers to explicitly SIMD-vectorize their Julia code. By exposing SIMD vector types and corresponding operations, the programmer can explicitly vectorize their code. While this does not guarantee that the generated machine code is efficient, it relieves the compiler from determining whether it is legal to vectorize the code, deciding whether it is beneficial to do so, and rearranging the code to synthesize vector instructions.

This package provides tools to help you develop code. Juno is built on the Atom text editor. Juno consists of both Julia and Atom packages in order to add Julia-specific enhancements, such as syntax highlighting, a plot pane, integration with Julia's debugger, a console for running code, and much more.

Consider that the package is “maintenance-only mode” and only receives bug fixes. The Julia IDE effort is pointed to extension for VSCode.

Julia bind to fzf fuzzy finder.

Plots is a plotting API and toolset.

This package provides a C-compatible enum for Julia.

Makie is a data visualization ecosystem for the Julia programming language.

Optim.jl is a package for univariate and multivariate optimization of functions.

A small package to transform between file extensions and MIME types, with bonus features.

Gumbo.jl is a Julia wrapper around Google's gumbo library for parsing HTML.

This package provides another JSON package for Julia, with a focus on speed and slick struct mapping.

This package allows you to query the availability of specific CPU features with low run-time cost.

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

This package provides a display system which enables the user handle multiple input/output devices and decide what media types get displayed where.

This package provides an archive of functions that emulate R's d-p-q-r functions for probability distributions. It is a wrapper around rmath for Julia.

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.

This package will provide a library of functions useful for machine learning, such as softmax, sigmoid, convolutions and pooling. It doesn't provide any other "high-level" functionality like layers or AD.

This Julia package provides the adapt(T, x) function acts like convert(T, x), but without the restriction of returning a T. This allows you to "convert" wrapper types like Adjoint to be GPU compatible without throwing away the wrapper.

libuv is a multi-platform support library with a focus on asynchronous I/O. Among other things, it supports event loops via epoll, kqueue, and similar IOCP, and event ports, asynchronous TCP/UDP sockets, asynchronous DNS resolution, asynchronous file system operations, and threading primitives.

A Pluto notebook is made up of small blocks of Julia code (cells) and together they form a reactive notebook. When you change a variable, Pluto automatically re-runs the cells that refer to it. Cells can even be placed in arbitrary order - intelligent syntax analysis figures out the dependencies between them and takes care of execution.

This is a slightly modified version of the standalone Rmath library from R, built to be used with the Rmath.jl Julia package. The main difference is that it is built to allow defining custom random number generating functions via C function pointers (see include/callback.h). When using the library, these should be defined before calling any of the random functions.

This package contains simple routines for finding roots, or zeros, of scalar functions of a single real variable using floating-point math. The find_zero function provides the primary interface. The basic call is find_zero(f, x0, [M], [p]; kws...) where, typically, f is a function, x0 a starting point or bracketing interval, M is used to adjust the default algorithms used, and p can be used to pass in parameters.

This package provides an R interface to Julia', which is a high-level, high-performance dynamic programming language for numerical computing, see <https://julialang.org/> for more information. It provides a high-level interface as well as a low-level interface. Using the high level interface, you could call any Julia function just like any R function with automatic type conversion. Using the low level interface, you could deal with C-level SEXP directly while enjoying the convenience of using a high-level programming language like Julia'.

This package provides a wrapper for the GR framework.