MLX Swift

The {fmt} library is organized into several headers providing specific formatting capabilities. All functions and types reside in the fmt namespace, and macros are prefixed with FMT_.

Key components include:

• fmt/base.h: Base API for char/UTF-8 with C++20 compile-time checks.
• fmt/format.h: Main formatting functions (fmt::format) and locale support.
• fmt/ranges.h: Formatting for ranges and tuples (e.g., std::vector).
• fmt/chrono.h: Date and time formatting.
• fmt/std.h: Formatters for standard library types.
• fmt/compile.h: Format string compilation.
• fmt/color.h: Terminal colors and text styles.
• fmt/os.h: System APIs.
• fmt/ostream.h: std::ostream support.
• fmt/args.h: Dynamic argument lists.
• fmt/printf.h: Safe printf implementation.
• fmt/xchar.h: Optional wchar_t support.

metal-cpp is a low-overhead, header-only C++ interface for Metal. It allows developers to call Metal functions directly from C++ code without creating an Objective-C shim. It provides a direct mapping of all Metal Objective-C classes, constants, and enums to the MTL C++ namespace.

Key characteristics:

• No measurable overhead compared to Objective-C due to inlining.
• No wrapper containers that require additional allocations.
• Requires C++17 (due to constexpr usage in NS::Object).
• Identical availability across iOS, macOS, and tvOS.

The {fmt} library is a high-performance C++ formatting library designed to address the limitations of existing methods like printf, iostreams, Boost Format, and FastFormat. It provides a fast, safe, and feature-rich alternative for string formatting, supporting positional arguments (useful for i18n), user-defined types, and advanced formatting options like leading zeros and hexadecimal encoding that other fast libraries may lack.

Key advantages include:

• Performance: Significantly faster than Boost Format and iostreams.
• Safety: Provides type safety and avoids the pitfalls of printf.
• Feature Completeness: Supports leading zeros, non-space padding, octal/hexadecimal encoding, and runtime width/alignment specification.
• Low Overhead: Designed to minimize build times and code bloat compared to heavy alternatives.

MLXNN provides several built-in layers for implementing positional encoding, which allows models to understand the order of elements in a sequence. The available implementations are:

• RoPE (Rotary Positional Embedding)
• SinusoidalPositionalEncoding
• ALiBi (Attention with Linear Biases)

MLX Swift provides built-in implementations of standard Transformer components to facilitate building neural network architectures. The primary components available are:

• MultiHeadAttention: Implements the multi-head attention mechanism used in Transformer architectures.
• Transformer: A high-level implementation of a Transformer block or model structure.

These layers are part of the MLXNN module and are designed to work with MLX tensors and neural network primitives.

MLX Swift is a Swift API for MLX, an array framework designed for machine learning on Apple silicon. While it follows the NumPy API closely, it introduces several key differences:

• Composable function transformations: Supports automatic differentiation, automatic vectorization, and computation graph optimization.
• Lazy evaluation: Computations are lazy; arrays are only materialized when needed.
• Multi-device support: Operations can run on supported devices like CPU and GPU.
• Unified Memory: Unlike many other frameworks, MLX arrays live in shared memory. Operations can be performed across different device types (CPU/GPU) without performing data copies.

An evaluation is triggered automatically (implicitly) whenever you attempt to access the underlying memory or data of an MLXArray. Common triggers include:

• Printing: Using print(array).
• Accessing Scalars: Calling MLXArray/item(_:) to retrieve a scalar value.
• Saving: Using save(arrays:metadata:url:stream:) or other MLX saving functions.
• Control Flow: Using a scalar array in a boolean context (e.g., if (y > 0).item() { ... }).

Warning: Using scalar arrays for control flow can be inefficient if it causes frequent evaluations.

func f(_ x: MLXArray) -> MLXArray {
    let (h, y) = firstLayer(x)

    // note: in python this is just "if y > 0:" which
    // has an implicit item() call in the boolean context
    let z: MLXArray
    if (y > 0).item() {
        z = secondLayerA(h)
    } else {
        z = secondLayerB(h)
    }
    return z
}

When creating tickets, choose the kind that matches your workload to optimize how the wired limit is managed:

• Active (kind: .active): Represents real, transient work (e.g., inference). Active tickets drive limit updates and keep the limit elevated while the work is running.
• Reservation (kind: .reservation): Represents long-lived memory (e.g., model weights). Reservations participate in admission and limit computation, but they do not keep the wired limit elevated while idle. This allows you to account for weights without wasting wired memory when no inference is occurring.

MLX uses Swift's SIMD naming convention for element-wise logical comparison operators. These operators compare two arrays (or an array and a scalar) element-wise and return a new MLXArray containing true/false values.

Supported comparison operators include:

• .== (Equal)
• .< (Less than)
• .<= (Less than or equal)
• .> (Greater than)
• .>= (Greater than or equal)
• .!= (Not equal)

When choosing a formatting method for your C++ project, consider the following trade-offs documented by {fmt}:

When converting from Python, note these naming patterns in MLX Swift:

1. Logical Operations: Element-wise comparisons use Swift SIMD conventions (e.g., .==, .<, .<=). These return a new MLXArray containing boolean values.
2. General Naming: Most functions and methods follow camelCase instead of Python's snake_case.
3. Non-mutating Methods: Some methods follow Swift conventions for functions that return new instances rather than mutating in place:
   • flatten() $\rightarrow$ flattened(start:end:stream:)
   • reshape() $\rightarrow$ reshaped(_:_:stream:)
   • moveaxis() $\rightarrow$ movedAxis(source:destination:stream:)