Hyperscript is a package for working with HTML, SVG, and CSS in Julia. When using this library you automatically get:

1. A concise DSL for writing HTML, SVG, and CSS.

2. Flexible ways to combine DOM pieces together into larger components.

3. Safe and automatic HTML-escaping.

4. Lightweight and optional support for scoped CSS.

5. Lightweight and optional support for CSS unit arithmetic.

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

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.

Cthulhu can help you debug type inference issues by recursively showing the code_typed output until you find the exact point where inference gave up, messed up, or did something unexpected. Using the Cthulhu interface you can debug type inference problems faster.

This package provides package developers an alternative option to delay package loading until used. If some dependency is not used, then users don't need to pay for its latency.

HypertextLiteral is a Julia package for generating HTML, SVG, and other SGML tagged content. It works similar to Julia string interpolation, only that it tracks hypertext escaping needs and provides handy conversions dependent upon context.

A left child, right sibling tree (frequently abbreviated as "LCRS") is a rooted tree data structure that allows a parent node to have multiple child nodes. Rather than maintain a list of children (which requires one array per node), instead it is represented as a binary tree, where the "left" branch is the first child, whose "right" branch points to its first sibling.

SnoopPrecompile is a small dependency used to effectively precompile code needed by your package, particularly on Julia 1.8 and higher.

This package provides a wrapper for fzf.

This package provides an abstraction layer over the FreeType Julia module.

Tricks.jl is an particularly cunning package that does tricks with the Julia edge system.

ProgressLogging.jl is a package for defining progress logs. It can be used to report progress of a loop/loops with time-consuming body.

This package provides basic arithmetic, integration, differentiation, evaluation, and root finding over dense univariate polynomials.

This package reads all method signatures in a package and generates precompile directives for any concrete signature that it can find.

This package provides an interface package for StaticArrays.jl.

This package provides a web server to run just the @bind parts of a Pluto.jl notebook.

Easy memoization for Julia.

This package provides a generic implementation of the marching squares algorithm for tracing contour curves on a scalar 2D field.

This package provides the Observables type in Julia, which are like Refs but you can listen to changes.

CodeTracking can be thought of as an extension of Julia's InteractiveUtils library. It provides an interface for obtaining:

1. the strings and expressions of method definitions

2. the method signatures at a specific file & line number

3. location information for "dynamic" code that might have moved since it was first loaded

4. a list of files that comprise a particular package.

This package provides a wrapper for Rmath.

TerminalLoggers provides a logger type TerminalLogger which can format your log messages in a richer way than the default ConsoleLogger which comes with the julia standard Logging library.

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.