All of these new words can get confusing! We’ve created a glossary to help nail down some Ivy terms that you might find tricky.

Automatic Code Conversions#

Allows code to be converted from one framework to another whilst retaining its functional assets.

Compositional Functions#

Compositional functions are functions that are implemented as a composition of other Ivy functions,

Convenience Functions#

Convenience functions can be used to organize and improve the code for other functions.


Frameworks are interfaces that allow scientists and developers to build and deploy machine learning models faster and easier. E.g. Tensorflow and PyTorch.

Framework Handler#
Backend Handler#

Used to control which framework Ivy is converting code to.

Graph Compiler#

Graph Compilers map the high-level computational graph coming from frameworks to operations that are executable on a specific device.

Ivy Array#

The ivy.Array is a simple wrapper class, which wraps around the ivy.NativeArray.

Ivy Backends#

Ivy Backends are supported frameworks that Ivy can convert code to. The default is NumPy.

Ivy Compiler#

A wrapper function around native compiler functions, which uses lower level compilers such as XLA to compile to lower level languages such as C++, CUDA, TorchScript, etc.

Ivy Container#

An Ivy class which inherits from dict allows for storing nested data.

Ivy Frontends#

Ivy Frontends are supported frameworks that Ivy can convert code from.

Ivy Functional API#

Is used for defining complex models, the Ivy functional API does not implement its own backend but wraps around other frameworks functional APIs and brings them into alignment.

Ivy Tracer#

Ivy’s Tracer creates a graph as a composition of functions in the functional API in Python.

Ivy Transpiler#

The transpiler allows framework to framework code conversions for supported frameworks.

Mixed Functions#

Mixed functions are functions that have some backend-specific implementations but not for all backends.

Native Array#

The ivy.NativeArray is simply a placeholder class for a backend-specific array class, such as np.ndarray, tf.Tensor or torch.Tensor.

Nestable Functions#

Nestable functions are functions that can accept ivy.Container instances in place of any of the arguments.


A pipeline is a means of automating the machine learning workflow by enabling data to be transformed and correlated into a model that can then be analyzed to achieve outputs.

Primary Functions#

Primary functions are the lowest level building blocks in Ivy and are generally implemented as light wrapping around an existing function in the backend framework, which serves a near-identical purpose.

Standalone Functions#

Standalone functions are functions that do not reference any other primary, compositional, or mixed functions whatsoever. These are mainly convenience functions.

Submodule Helper Functions#

These are standalone/convenience functions that are specific to a submodule.