airbnb/lottie-ios

This system is the Lottie iOS library, a cross-platform framework for rendering vector-based animations on Apple devices including iOS, macOS, tvOS, and visionOS. It provides two distinct rendering engines—a high-performance Core Animation path and a main-thread node-based system—allowing developers to choose the best fit for their performance and compatibility needs. The library supports loading animations from JSON and DotLottie archives, offers dynamic property control via keypaths, and includes declarative SwiftUI and UIKit components for interactive animation playback.

36 changes.

The project transitioned from a legacy iOS-only app structure to a modern, multi-platform framework supporting iOS, macOS, tvOS, and visionOS. This period focused on refactoring the core animation engine to handle complex features like 3D transforms, drop shadows, and dotLottie archives, while introducing a robust public API for dynamic property control and runtime customization. Concurrently, the codebase was hardened for strict concurrency, improved caching, and comprehensive testing across all supported platforms.

28 changes.

This period focused on implementing two new rendering backends: a high-performance Core Animation engine and a flexible main-thread node-based system. These additions expanded support for complex animation features like 3D transforms, gradients, and text animators while improving stability through configurable logging and DotLottie archive support.

15 changes.

This period focused on establishing a foundational declarative model layer within EpoxyCore, introducing diffing engines and standardized view configuration protocols to enable efficient UI updates. The team significantly expanded SwiftUI interoperability by adding bridging utilities, layout measurement improvements, and a complete rewrite of the example app to demonstrate these capabilities. Concurrently, the Lottie library introduced a global configuration API, cross-platform animated controls, and enhanced rendering features like drop shadows, while addressing security and privacy compliance requirements.

Introduces a new \DotLottieCache\ implementation and \DotLottieCacheProvider\ protocol to cache loaded \.lottie\ archive files. This feature allows applications to store up to 100 Lottie files by default, using an LRU (Least Recently Used) strategy to manage memory, which improves performance when loading the same animations multiple times.

Sources/Public/DotLottie/Cache · high confidence

The EpoxyCore library now includes a new SwiftUI module that allows EpoxyableViews and standard UIViews to be embedded directly within SwiftUI hierarchies. This adds \swiftUIView()\ factory methods to convert Epoxy models and UIKit views into SwiftUI \View\ types, supporting configuration closures and intrinsic sizing strategies. It also introduces environment-based utilities for handling layout margins and intrinsic content size invalidation, enabling seamless interoperability between the Epoxy UIKit rendering engine and SwiftUI layouts.

Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI · high confidence

New Objective-C compatible classes and protocols have been added to the iOS compatibility layer, enabling Swift-based Lottie features to be used from Objective-C projects. This includes \CompatibleAnimationView\ for rendering animations with configurable rendering engines and background behaviors, \CompatibleAnimationKeypath\ for keypath-based animation control, and \CompatibleAnimationFontProvider\ and \CompatibleAnimationImageProvider\ protocols for custom font and image asset resolution. These wrappers bridge Swift-specific types like \AnimationKeypath\ and \LottieConfiguration\ into \@objc\-compatible interfaces.

Sources/Public/iOS/Compatibility · high confidence

A new standalone iOS application named SizeTest has been added to the script directory to serve as a dedicated test harness for verifying Lottie animation file sizes. The app integrates the Lottie framework and displays a specific animation sample (9squares\_AlBoardman.json) within a standard iOS view controller, allowing developers to visually and programmatically assess the rendering footprint of animation assets.

script/SizeTest · high confidence

Introduces new UIKit/AppKit controls—AnimatedControl, AnimatedButton, and AnimatedSwitch—that play Lottie animations in response to user interactions (taps, clicks, state changes). AnimatedButton plays a specified animation range on touch events and exposes a performAction callback, while AnimatedSwitch toggles its state with distinct 'on' and 'off' animation ranges, haptic feedback on iOS, and configurable cancel behavior. To support SwiftUI, the library also adds LottieButton and LottieSwitch views that wrap these controls, allowing declarative configuration of animations, action handlers, and state bindings. The implementation uses platform-specific typealiases to unify UIControl (iOS/tvOS) and NSControl (macOS) behaviors.

Sources/Public/Controls · high confidence

The main thread rendering engine now supports drop shadow effects on layers. This change introduces a new \DropShadowNode\ that applies shadow properties (opacity, color, radius, angle, and distance) to a \CALayer\, including necessary conversions for Lottie animation formats (e.g., percentage opacity to decimal, degrees to radians). A base \LayerEffectNode\ protocol and extension are also added to manage property updates and effect application.

Sources/Private/MainThread/NodeRenderSystem/Nodes/LayerEffectNodes · high confidence

The library now supports keyframe-based animations through the ValueProviders API. This change introduces the \KeyframeInterpolator\ class, which calculates values at specific frames by interpolating between defined keyframes, and adds \Interpolatable\ extensions for \LottieColor\, \CurveVertex\, \BezierPath\, and \TextDocument\ to enable smooth transitions between these types. Users can now define complex animations with hold states and cubic bezier easing by specifying keyframes with time, value, and tangent data.

Sources/Private/Utility/Interpolatable · high confidence

This change introduces native macOS support by adding platform-specific implementations for the core animation view and image providers. It includes \LottieAnimationViewBase\ to handle view lifecycle and layout on macOS, \AnimationSubview\ for keypath-based subviews, and macOS-adapted versions of \BundleImageProvider\ and \FilepathImageProvider\ that correctly resolve images using \NSImage\ and handle base64-encoded data. These components enable developers to render Lottie animations in macOS applications using the same API surface as iOS.

Sources/Public/macOS · high confidence

The main thread rendering engine now supports the 'Rounded Corners' animation modifier. A new RoundedCornersNode has been added to process path data, applying a configurable radius to shapes during rendering. This allows animations utilizing rounded corner effects to be displayed correctly on the main thread, matching the behavior previously available only in the Core Animation engine.

Sources/Private/MainThread/NodeRenderSystem/Nodes/ModifierNodes · high confidence

Users can now load .lottie files (ZIP archives containing Lottie JSON animations and assets) in addition to standard .json files. This change introduces the ability to handle multiple animations within a single .lottie archive, with playback settings (loop, speed, direction, mode) defined in the archive's manifest. It also adds support for the IANA-registered .lot file extension as an alias for .json, and improves image loading reliability by using a dictionary-based provider instead of NSCache to prevent image eviction during playback.

Sources/Private/Model/DotLottie · high confidence

The EpoxyCore library now includes a new diffing subsystem that computes minimal change sets (inserts, deletes, updates, and moves) for collections. This addition introduces protocols for \Diffable\ and \DiffableSection\ items, along with data structures for \IndexChangeset\, \IndexPathChangeset\, \IndexSetChangeset\, and \SectionedChangeset\. The \Collection\ extension provides methods to generate these changesets, enabling efficient UI updates by identifying exactly which items have changed, moved, or been removed between two states.

Sources/Private/EmbeddedLibraries/EpoxyCore/Diffing · high confidence

The project now includes dedicated Xcode schemes for the Example app, specifically 'Example (Multiplatform)' and 'Example (iOS)'. These schemes configure the build environment to include the Lottie framework targets for tvOS, macOS, and iOS, allowing developers to build, run, test, and archive the example applications directly within Xcode.

Example/Example.xcodeproj/xcshareddata · high confidence

Introduced a new \DictionaryInitializable\ protocol and helper extensions that allow model objects to be initialized from raw dictionary data. This change enables alternative decoding paths for parsing JSON or other dictionary-based inputs, improving flexibility in how model data is hydrated without requiring direct object instantiation.

Sources/Private/Model · high confidence

The \AnimationImageProvider\ protocol now includes a \contentsGravity(for:)\ method, allowing users to control how image assets are positioned or scaled within their bounds during animation playback. While the default behavior remains \.resize\ (stretching the image to fill the layer), this new capability enables custom providers to specify alternative gravity settings, such as centering or aspect-fit, providing finer control over the visual presentation of embedded images in Lottie animations.

Sources/Public/ImageProvider · high confidence

The project now includes the source code for the LRUCache library (version 1.0.2) directly within the private embedded libraries directory. This change embeds the cache implementation to avoid external dependency issues with package managers, making the cache functionality available internally to the Lottie library without exposing it as a public API.

Sources/Private/EmbeddedLibraries/LRUCache · high confidence

This change establishes the foundational structure for the Lottie iOS library, introducing essential configuration and documentation files. It adds a .gitignore to exclude build artifacts and IDE files, an .npmignore to control NPM package contents, and a .spi.yml to configure documentation generation on the Swift Package Index. A new README.md provides installation instructions for Swift Package Manager, CocoaPods, and Carthage, along with usage examples and privacy/security notices. The project also includes a Rakefile to automate building, testing, and linting across iOS, macOS, tvOS, and visionOS, and a Version.xcconfig to set the marketing version to 4.6.1. Additionally, an index.js is added to clarify that the NPM module has no JavaScript export, and the legacy PrefixHeader.pch is removed.

(repo-wide) · high confidence

This change adds a new Core Animation-based rendering engine to the library, implemented in the \Sources/Private/CoreAnimation/Animations\ directory. It introduces a suite of new files (such as \CAAnimation+TimingConfiguration.swift\, \CALayer+addAnimation.swift\, \DropShadowAnimation.swift\, and \GradientAnimations.swift\) that handle the mapping of Lottie animation data to native \CALayer\ properties. This engine supports advanced features including drop shadows, gradient animations (linear and radial), stroke and fill opacity, trim paths, and custom value providers, providing a high-performance alternative to the existing rendering path.

Sources/Private/CoreAnimation/Animations · high confidence

The EpoxyCore library now includes a new Model layer that enables declarative UI models using a property-based system. This introduces the \EpoxyModeled\ protocol as the base for all models, backed by \EpoxyModelStorage\ for storing property values. Models can now define custom properties via \EpoxyModelProperty\, which supports update strategies like replace or chain. The diff adds several provider protocols (e.g., \DataIDProviding\, \MakeViewProviding\, \SetContentProviding\, \DidSelectProviding\) that extend models with specific capabilities like data identification, view construction, content setting, and lifecycle callbacks. A new \EpoxyModelArrayBuilder\ result builder allows for concise DSL-style array construction of models. This change establishes the foundational model architecture for Epoxy's declarative UI approach.

Sources/Private/EmbeddedLibraries/EpoxyCore/Model · high confidence

A new \LottieAnimationSource\ enum has been added to the utility layer to serve as a unified data source for Lottie animations, supporting both standard \.json\ animations and \.lottie\ (DotLottie) files. This abstraction allows SwiftUI views to accept either animation type seamlessly, simplifying the integration of async animation loading and configuration in the UI layer.

Sources/Private/Utility · high confidence

A new \MainThreadAnimationLayer\ class has been added to serve as the base \CALayer\ for a main-thread-based Core Animation rendering engine. This implementation allows animations to be rendered directly on the main thread, supporting configuration via \maskAnimationToBounds\ to clip content to the layer bounds and \forceDisplayUpdateOnEachFrame\ to force a full render on every frame (useful for working around specific rendering bugs at the cost of performance). The layer initializes composition layers, resolves track mattes, and manages image, text, and font providers.

Sources/Private/MainThread/LayerContainers · high confidence

This change introduces the core NodeProperty infrastructure within the NodeRenderSystem, establishing a new mechanism for managing animation property values. It adds the \NodeProperty\ class and \AnyNodeProperty\ protocol, which allow properties to be driven by \ValueProvider\ instances and support setting or removing these providers at runtime. The update also includes \ValueContainer\ for storing typed values, \GroupInterpolator\ and \SingleValueProvider\ for generating animation values, and the \KeypathSearchable\ protocol to enable searching and accessing node properties via keypaths.

Sources/Private/MainThread/NodeRenderSystem/NodeProperties · high confidence

Added ShapeContainerLayer and ShapeRenderLayer classes to the rendering system. ShapeContainerLayer acts as a base container for managing sub-layers and render scale updates, while ShapeRenderLayer handles the actual drawing of shape objects by coordinating with renderers to update paths, fills, and strokes on a CAShapeLayer.

Sources/Private/MainThread/NodeRenderSystem/RenderLayers · high confidence

This change adds a new main-thread rendering engine for Lottie animations, implemented through a hierarchy of composition layers (CompositionLayer, ImageCompositionLayer, ShapeCompositionLayer, TextCompositionLayer, etc.) in the CompLayers module. Users can now render Lottie animations on the main thread, which may improve compatibility with certain UI frameworks or debugging scenarios. The implementation supports core animation features including masks, blend modes, drop shadows, and text animators, while also introducing specific behaviors for image content gravity and track matte resolution.

Sources/Private/MainThread/LayerContainers/CompLayers · high confidence

Added new internal primitive types for handling Bezier paths, including BezierPath, CompoundBezierPath, CurveVertex, and PathElement, along with a BezierPathRoundExtension that implements a corner-rounding algorithm. This change introduces the underlying geometry structures and the specific logic required to round corners on shapes, supporting the rounded corner feature in the rendering engines.

Sources/Private/Utility/Primitives · high confidence

This change introduces the \Sources/Public/DynamicProperties\ module, exposing \AnimationKeypath\ and \AnyValueProvider\ to allow users to dynamically modify animation properties at runtime. \AnimationKeypath\ enables targeting specific nodes within an animation using dot-separated strings and wildcard support, while \AnyValueProvider\ allows binding custom values, closures, or keyframes to those paths, updating the animation frame-by-frame.

Sources/Public/DynamicProperties · high confidence

This release adds several new public types to the iOS SDK to improve animation rendering and asset handling. Users can now configure image content gravity via \BundleImageProvider\ and \FilepathImageProvider\, which also include fixes for handling base64-encoded images and data URLs. The \LottieAnimationViewBase\ class is introduced to standardize layout and lifecycle management across platforms, while \AnimationFontProvider\ and \DefaultFontProvider\ allow custom font supply. Additionally, \AnimationSubview\ enables adding custom views to animation keypaths, and a \UIColor\ extension simplifies color conversion for animations.

Sources/Public/iOS · high confidence

A new EpoxyLogger class has been added to the EpoxyCore library, providing a shared logger that allows consumers to intercept Epoxy assertions and warning messages to pipe into their own logging systems. This change enables better integration with custom logging infrastructure by exposing the internal logging mechanisms (assert, assertionFailure, and warn) through a configurable singleton, while ensuring that default assertions respect the Swift compiler's optimization flags to prevent unexpected crashes in release builds.

Sources/Private/EmbeddedLibraries/EpoxyCore/Logging · high confidence

The EpoxyCore library now exposes a structured protocol hierarchy (BehaviorsConfigurableView, ContentConfigurableView, StyledView, and EpoxyableView) that separates view configuration into invariant styles, equatable content, and non-equatable behaviors. This change provides a standardized, declarative way to configure views within the Epoxy framework, allowing for more efficient view reuse and updates by distinguishing between properties that change frequently (content/behaviors) and those that remain constant (style).

Sources/Private/EmbeddedLibraries/EpoxyCore/Views · high confidence

The library now includes a new Core Animation-based rendering engine (located in \Sources/Private/CoreAnimation/Layers\) that renders Lottie animations using native \CALayer\ hierarchies. This engine supports a wide range of features including shape layers, gradients with alpha components, masks (including inverted masks), pre-composition layers with time remapping, repeaters, drop shadows, and text layers. It also introduces runtime capabilities such as \allHierarchyKeypaths()\ for inspecting animation structure and \ValueProvider\ support for dynamic customization of colors, opacity, position, scale, and rotation. This provides a high-performance rendering alternative to the existing main-thread engine, with fallbacks in place for unsupported features.

Sources/Private/CoreAnimation/Layers · high confidence

The Lottie library now includes a new Core Animation rendering engine (located in Sources/Private/CoreAnimation) as an alternative to the existing animation system. This engine introduces a \CompatibilityTracker\ to detect and report unsupported animation features during setup, allowing for graceful handling of incompatible content. It adds support for dynamic customization via \ValueProvider\s for properties like opacity, position, scale, and rotation, while explicitly rejecting closure-based providers to maintain performance. The implementation also includes fixes for memory allocation issues by avoiding unnecessary direct rendering in the root layer, correct handling of wildcard keypaths for value provider matching, and proper state management for animation playback and pausing.

Sources/Private/CoreAnimation · high confidence

This change introduces a new SwiftUI-compatible \LottieView\ wrapper, allowing developers to embed Lottie animations directly in SwiftUI interfaces with support for asynchronous loading, placeholders, and configuration modifiers. It also introduces a unified \LottiePlaybackMode\ enum to replace the previous fragmented \play\ method overloads, providing a consistent way to control playback (progress, frames, markers) and pause states across both the new SwiftUI view and the existing \LottieAnimationView\. The diff also includes the foundational \LottieAnimation\ model and \LottieAnimationLayer\ CALayer subclass, which serve as the core rendering engine for these views.

Sources/Public/Animation · high confidence

The library now exposes core data structures in the \Sources/Public/Primitives\ module, allowing users to interact directly with animation primitives. This includes \AnimationTime.swift\ which defines \AnimationFrameTime\ and \AnimationProgressTime\ as \CGFloat\ typealiases for representing time and progress. \LottieColor.swift\ introduces the \LottieColor\ struct and \ColorFormatDenominator\ enum to handle color values with configurable denominators (1, 100, or 255). Additionally, \Vectors.swift\ provides \LottieVector1D\ and \LottieVector3D\ structs, conforming to \Hashable\ and \Sendable\, to represent 1D and 3D vector data used in animations.

Sources/Public/Primitives · high confidence

The main thread rendering engine now supports the RoundedCorners shape item, allowing animations with rounded corners to be rendered on the main thread instead of requiring the Core Animation engine. This change adds a new \ItemsExtension.swift\ file that initializes a \RoundedCornersNode\ when processing shape items, enabling this visual effect in the main thread renderer.

Sources/Private/MainThread/NodeRenderSystem/Extensions · high confidence

The Example app has been rewritten in SwiftUI, replacing the previous implementation. It now features an \AnimationListView\ that browses local JSON and .lottie files, and an \AnimationPreviewView\ that allows users to control playback (play/pause, scrubbing, loop modes, rendering engine selection) and load animations asynchronously with placeholders. The app includes dedicated demo views for controls (\LottieSwitchRow\, \LottieButtonRow\), layout behaviors (\LottieViewLayoutDemoView\), and SwiftUI interoperability (\SwiftUIInteroperabilityDemoView\), demonstrating features like marker-based animation, color value providers, and placeholder size inheritance.

Example/Example · high confidence

Added new debugging capabilities to the library, including \printNodeTree()\ for visualizing the AnimatorNode hierarchy and \logLayerTree()\ for logging the Core Animation layer structure. The \LayerDebugging\ module introduces visual debug overlays (DebugLayer) that can be toggled on composition layers to display anchor points and bounds, with specific styling for top, null, and shape layers. These tools are gated behind the DEBUG preprocessor directive and include test helpers to detect when snapshot or performance tests are running.

Sources/Private/Utility/Debugging · high confidence

A new \LottieConfiguration\ struct and supporting types (\DecodingStrategy\, \ReducedMotionOption\, \RenderingEngineOption\, \LottieURLSession\) have been introduced to allow global control over animation behavior. Users can now configure the default decoding strategy (switching to the faster \dictionaryBased\ approach), select between Core Animation and Main Thread rendering engines, manage reduced motion preferences (including a \disabledMotion\ mode for snapshot testing), and override the URL session used for loading remote animations.

Sources/Public/Configuration · high confidence

The library now exposes a new public \Keyframes\ module containing the \Interpolatable\ and \SpatialInterpolatable\ protocols, along with the \Keyframe\<T\>\ class. This addition allows users to define custom interpolation logic for animation values and provides built-in support for interpolating standard types like \Double\, \CGRect\, \CGPoint\, and \LottieColor\, including spatial tangents for smoother vector animations.

Sources/Public/Keyframes · high confidence

The library adds model classes for new Lottie shape items, including Ellipse, Fill, GradientFill, GradientStroke, Group, Merge, Rectangle, Repeater, RoundedCorners, Shape, ShapeTransform, Star, Stroke, and Trim, enabling the parsing and rendering of these specific animation elements. Additionally, all shape item classes now explicitly conform to \@unchecked Sendable\ to support strict concurrency checking in modern Swift environments.

Sources/Private/Model/ShapeItems · high confidence

This change introduces dedicated public ValueProvider classes—ColorValueProvider, FloatValueProvider, GradientValueProvider, PointValueProvider, and SizeValueProvider—within the DynamicProperties module. These providers allow users to supply static values, dynamic closures, or keyframe-based animations for specific data types (colors, floats, gradients, points, and sizes), enabling more granular control over animation properties compared to generic providers.

Sources/Public/DynamicProperties/ValueProviders · high confidence

The library now allows loading Lottie animations using the \.lot\ (IANA-registered alias for Lottie JSON) and \.lottie\ (dotLottie archive) file extensions. The \Bundle\ extension automatically strips these suffixes during resource lookup, ensuring compatibility with filenames that include the extension, while also maintaining support for standard \.json\ files and data assets.

Sources/Private/Model/Extensions · high confidence

The animation engine now supports 3D rotations on the X and Y axes, allowing animations with 3D transform data to be parsed and rendered correctly. This change introduces new internal model objects to handle specific animation data structures: DashPattern for stroke dash arrays, Marker for time-based markers with duration support, Mask for layer masking modes and properties, and an updated Transform class that explicitly handles rotationX, rotationY, and rotationZ keyframes alongside position and scale.

Sources/Private/Model/Objects · high confidence

The renderer now supports animating basic geometric shape layers. This change adds dedicated node implementations for Ellipse, Polygon, Rectangle, and Star shapes, allowing users to import and play animations containing these vector primitives with full keyframe interpolation for properties like position, size, radius, and rotation.

Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes · high confidence

The text rendering system now supports a comprehensive set of animator properties for text layers, including opacity, position, scale, rotation (with specific support for X and Y axes in addition to Z), skew, stroke color, fill color, stroke width, and tracking. This allows animations to manipulate these visual attributes over time using keyframe interpolators, enabling more complex and dynamic text effects within Lottie animations.

Sources/Private/MainThread/NodeRenderSystem/Nodes/Text · high confidence

The library now parses and models drop shadow effects (including color, opacity, direction, distance, and softness) via new \DropShadowEffect\ and related value classes, allowing animations with these effects to be loaded correctly. Additionally, layer models now include logic to resolve track mattes by explicitly referencing parent layers (\tp\) or falling back to adjacent layers, ensuring that masked layers are rendered in the correct z-order without being drawn independently.

Sources/Private/Model/Layers · high confidence

Developers can now load .lottie archive files, which may contain multiple animations, using new public APIs in \DotLottieFile\. The library introduces \DotLottieConfiguration\ to store animation presets (such as loop mode, speed, and image provider) extracted from the file, and \DotLottieConfigurationComponents\ to control which of these presets override existing \LottieView\ settings. Loading is supported via synchronous methods (with caching), asynchronous methods, and completion handlers, with the ability to specify a dispatch queue for background processing.

Sources/Public/DotLottie · high confidence

The LotteAnimator iOS application project (LotteAnimator.xcodeproj) has been deleted. This removes the sample app, its source files (including AppDelegate, ViewController, and model classes like LALayer and LAShape), and its CocoaPods configuration from the repository.

LotteAnimator.xcodeproj · high confidence

The Mantle library (version 2.0.6) has been removed from the project's Pods. This eliminates the external dependency on Mantle for model serialization, JSON mapping, and archiving, requiring the application to rely on alternative implementations for these data-handling capabilities.

Pods · high confidence

The \LotteAnimator\ iOS application entry point (AppDelegate, ViewController, main.m) and its associated UI components (LACompView, LALayerView) have been removed, along with the data models (LAScene, LALayer, LAMask, LAPath, LAShape) and utility classes (BWMath, UIColor+Expanded) that rendered the animations. This change strips the project of its standalone iOS app structure and the specific rendering logic that parsed the \data.json\ animation file, leaving only the framework-level code.

LotteAnimator · high confidence

The embedded ZIPFoundation library has been upgraded to version 0.9.20. This update addresses a symlink path traversal vulnerability during ZIP extraction, ensuring that symbolic links are validated to prevent access to paths outside the intended destination directory. The diff also reflects broader API modernization, including the deprecation of non-throwing initializers in favor of throwing ones, the migration of \bufferSize\ parameters from \UInt32\ to \Int\, and the addition of support for in-memory archives via a new \MemoryFile\ implementation.

Sources/Private/EmbeddedLibraries/ZipFoundation · high confidence

A change to existing behaviour in \_AeFiles — 3 commits, 12 files.

_\AeFiles · medium confidence · unverified

The text animation engine now supports animating text opacity and applying 3D rotations on the X and Y axes, allowing for more complex typographic effects. Additionally, the underlying text model decoding has been hardened to prevent failures when optional font ascent or line height data is missing, and to correctly handle justified text layouts, ensuring animations with these properties render reliably.

Sources/Private/Model/Text · high confidence

The project now includes the standard Xcode workspace data file (contents.xcworkspacedata) and the IDEWorkspaceChecks.plist file. These additions ensure the workspace is correctly recognized by Xcode and help prevent build inconsistencies by tracking workspace integrity, addressing issues with Carthage builds and aligning with Xcode 9.3 recommendations.

Lottie.xcodeproj/project.xcworkspace · high confidence

A new PrivacyInfo.xcprivacy file has been added to the Sources directory to comply with Apple's privacy requirements. This manifest declares that the library accesses the file timestamp API (NSPrivacyAccessedAPICategoryFileTimestamp) and provides the corresponding reason code (C617.1), ensuring proper disclosure for App Store submissions.

Sources · high confidence

The Core Animation rendering engine now supports time remapping, allowing animations to be played at variable speeds or reversed by manually interpolating keyframes based on a global-to-local time mapping. Additionally, the engine can now combine multiple keyframe groups (up to ten properties) into a single animation stream, enabling simultaneous animation of complex property sets like shape bezier paths, radial gradient endpoints, and skew transforms that previously might have required separate handling or suffered from interpolation issues.

Sources/Private/CoreAnimation/Extensions · high confidence

The example application has been replaced with a new multiplatform SwiftUI app named "Example (Multiplatform)". This change introduces demo views for LottieButton, LottieSwitch, and animation browsing, allowing users to explore available sample animations across supported platforms.

Example/Example.xcodeproj · high confidence

The EpoxyCore library now includes new internal layout utilities (\MeasuringViewRepresentable\ and \SwiftUIMeasurementContainer\) that enable more accurate size reporting when embedding UIKit views within SwiftUI. These components bridge the gap between UIKit's layout system and SwiftUI's measurement requirements by supporting both legacy private APIs (for iOS 13–15) and the public \sizeThatFits\ API (for iOS 16+), ensuring that embedded views correctly report their intrinsic content sizes and handle proposed size constraints without layout failures.

Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/LayoutUtilities · high confidence

This change introduces several internal helper files to support animation lifecycle management and improve SwiftUI compatibility. AnimationContext.swift defines the internal structure for tracking animation state (playing, cancelled, complete) and delegates completion callbacks, while AnyEquatable.swift provides a generic equality wrapper. Additionally, Binding+Map.swift adds a utility to transform SwiftUI bindings, and View+ValueChanged.swift implements a backwards-compatible wrapper for the \onChange\ modifier, ensuring correct behavior across iOS 14 through 17 and other platforms by falling back to \onReceive\ when necessary.

Sources/Private/Utility/Helpers · high confidence

Added new internal model classes (Asset, AssetLibrary, ImageAsset, PrecompAsset) to handle Lottie manifest assets, including support for dictionary-based decoding. ImageAsset now safely decodes Base64 data URLs by trimming whitespace and checking available process memory before decoding, preventing log flooding and potential memory exhaustion.

Sources/Private/Model/Assets · high confidence

The animation caching system has been refactored to support strict concurrency and allow customization. A new \AnimationCacheProvider\ protocol defines the caching interface, and \DefaultAnimationCache\ serves as the default implementation, utilizing an LRU strategy that responds to memory pressure. The previous \LRUAnimationCache\ type is now a deprecated typealias pointing to this new default. Users can now customize the cache provider used for loading animations by setting \LottieAnimationCache.shared\.

Sources/Public/AnimationCache · high confidence

This change introduces a new main-thread rendering architecture for Lottie animations, replacing the previous Core Animation-based approach with a node-based system that computes paths and renders them directly via Core Graphics. The new system includes specific output nodes for groups, paths, and pass-throughs, along with renderers for fills, strokes, and gradients. A key behavioral update is that gradient fills and strokes now respect the \LottieConfiguration.colorSpace\ setting, allowing users to configure the color space used for gradient rendering to ensure consistent appearance across different devices and contexts.

Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes · high confidence

A new \LottieLogger\ class is added to the public API, allowing consumers to intercept and customize how Lottie handles assertions, warnings, and informational messages. The default implementation wraps standard Swift assertions but explicitly avoids calling \Swift.assert\ directly to prevent unexpected crashes in release builds (addressing Swift issue \#60249). It also provides a \printToConsole\ static property for a logger that outputs to the console instead of halting execution, giving users control over logging behavior without risking app stability.

Sources/Public/Logging · high confidence

The render system now exposes foundational protocols (\AnimatorNode\, \NodeOutput\, \PathNode\, \RenderNode\, \Renderable\) that define the structure of the animation node tree. \AnimatorNode\ establishes the base logic for frame updates, property mapping, and upstream/downstream state propagation, while \RenderNode\ and \Renderable\ define the interface for actual drawing operations, including support for custom drawing contexts and shape layer updates. \PathNode\ and \NodeOutput\ standardize how path data is exposed and managed within the hierarchy. These protocols form the backbone of the main-thread rendering pipeline, enabling nodes to efficiently determine when updates are needed and how to propagate changes through the animation tree.

Sources/Private/MainThread/NodeRenderSystem/Protocols · high confidence

The Lottie Xcode project file has been updated to register a comprehensive set of Swift source files for the build. This includes the core animation rendering engine components (such as CoreAnimationLayer, MainThreadAnimationLayer, and various shape/text/gradient renderers), the public API surface (LottieAnimationView, LottieView, AnimatedControl, AnimatedSwitch, AnimatedButton), and supporting infrastructure for caching, image/font providers, and dotLottie file handling. This change ensures these specific implementation files are correctly included in the compiled framework.

Lottie.xcodeproj · high confidence

Added new \FillNode\, \StrokeNode\, \GradientFillNode\, and \GradientStrokeNode\ render nodes to the main-thread rendering system. The stroke implementations now correctly handle dash patterns by converting zero-length dash segments to 0.01 to prevent Core Animation from rendering round dots as pills, and skip rendering entirely when all dash lengths are zero to avoid performance issues.

Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes · high confidence

This change introduces several new internal utility classes to support the animation engine: a cached image provider to reuse assets, a composition layer initializer to map animation layers to their container types, a CoreText render layer for improved text rendering, an inverted matte layer for alpha inversion, and provider wrappers (LayerFontProvider, LayerImageProvider, LayerTextProvider) to connect external providers to specific layer groups. It also adds a LayerTransformNode to handle transform properties including 3D rotations.

Sources/Private/MainThread/LayerContainers/Utility · medium confidence

The library introduces new internal model classes, KeyframeData and KeyframeGroup, to standardize the parsing of animation keyframe JSON. This refactoring normalizes various JSON formats into a consistent internal structure, ensuring robust decoding of keyframe arrays and raw values. Additionally, the new parsing logic detects and stores unsupported After Effects expressions found in animation files, enabling the system to log warnings when such expressions are encountered during playback.

Sources/Private/Model/Keyframes · high confidence

This change introduces a suite of new utility extensions in the private utility layer to support animation rendering and configuration. The \AnimationKeypathExtension\ adds recursive search capabilities for animator nodes, properties, and layers, enabling precise targeting of animation elements via keypaths. \BlendMode+Filter\ maps animation blend modes to their corresponding Core Image compositing filter names, allowing these effects to be applied to CALayers. \CGColor+RGB\ provides helpers to extract RGB values and create colors using a configurable color space from \LottieConfiguration\. Additionally, \CGFloatExtensions\ and \MathKit\ supply mathematical utilities for cubic bezier interpolation, value clamping, and geometric calculations, while \DataExtension\ and \StringExtensions\ add asset loading and hex-color parsing helpers.

Sources/Private/Utility/Extensions · high confidence

The public API for dynamic text in Lottie animations has been restructured. A new \AnimationKeypathTextProvider\ protocol is now the preferred way to provide dynamic text, replacing the deprecated \AnimationTextProvider\ (now aliased to \LegacyAnimationTextProvider\). The new protocol uses \AnimationKeypath\ objects for more precise keypath matching, while the legacy protocol remains available for backward compatibility. Additionally, a \TextContentsScaleProvider\ protocol allows customizing the content scale of rendered text to reduce aliasing. Existing implementations like \DictionaryTextProvider\ and \DefaultTextProvider\ have been updated to conform to both protocols.

Sources/Public/TextProvider · high confidence

The rendering engine for group nodes now supports 3D rotations on the X and Y axes, in addition to the existing Z-axis rotation. This change introduces new properties for opacity, position, scale, and rotation (including the new 3D axes) within the \GroupNode\ and \GroupNodeProperties\ classes, allowing animations to utilize more complex spatial transformations.

Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderContainers · high confidence

The script/test-spm location now includes a newly created Xcode workspace (LottieSPM.xcworkspace) to manage the project structure, alongside a Mintfile that pins the xcbeautify build tool at version 0.10.2. These changes support the broader effort to fix Carthage build issues and add visionOS support by providing a standardized environment for testing the Swift Package Manager integration.

script/test-spm · medium confidence

The Xcode project schemes have been consolidated under the Lottie.xcodeproj, replacing the legacy LotteAnimator and Pods-based schemes. iOS, macOS, and tvOS schemes now target the Lottie framework (Lottie-iOS, Lottie-macOS, Lottie-tvOS) instead of the previous app or static library targets, and the scheme files have been upgraded to Xcode version 14.30. Additionally, a new visionOS scheme has been added to support building and testing the Lottie-visionOS target, enabling development for Apple's new platform.

Lottie.xcodeproj/xcshareddata · high confidence

The Lottie.xcworkspace has been reconfigured to resolve build issues with Carthage. The workspace file was renamed from LotteAnimator.xcworkspace to Lottie.xcworkspace, and its internal references were updated to point to the main Lottie.xcodeproj and the Example app, ensuring the project structure aligns with Carthage's expectations.

Lottie.xcworkspace · high confidence

5 commits adding/updating tests in Tests/Samples/DotLottie; Added Carthage integration test project; Added comprehensive test suite for Lottie animation rendering and configuration; Added test samples for Lottie issue \#1125 and \#1169; Added test utilities for snapshot testing and mock providers.

This release updates the library to version 4.6.1 and adds support for visionOS, macOS, and tvOS, with minimum deployment targets set to iOS 13.0, macOS 10.15, tvOS 13.0, and visionOS 1.0. The Swift Package Manager manifest now declares these platforms and includes a privacy resource bundle. CocoaPods dependencies have been updated to use \cocoapods\ 1.15.0 and \cocoapods-downloader\ 2.1, while the legacy \Mantle\ dependency has been removed in favor of a modern framework structure. Development tooling now requires Ruby gems \cocoapods\ (\~\> 1.15.0), \rake\ (\~\> 13.0.0), and \git\ (\~\> 1.18), and Swift Package dependencies for \airbnb/swift\ and \swift-argument-parser\ have been pinned to specific versions across various resolved files.

(dependencies) · high confidence

The local Xcode breakpoint list file (Breakpoints\_v2.xcbkptlist) has been deleted from the workspace. This removes specific debug breakpoints that were previously configured for internal development files such as LACompView.m, ViewController.m, and LALayerView.m, ensuring a cleaner workspace state for new users or CI environments.

LotteAnimator.xcworkspace · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 64 → 62 (-2.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 → 89 (-9.4)
• Architecture 99 → 97 (-1.9)
• Maturity 59 → 58 (-0.7)
• Readiness 57 → 53 (-3.6)
• Security 62 → 69 (+6.4)
• Domain Modelling 100 → 90 (-9.9)

• Change coupling: CustomPathAnimation.swift ↔ RectangleAnimation.swift (Sources/Private/CoreAnimation/Animations/CustomPathAnimation.swift)
• Change coupling: CustomPathAnimation.swift ↔ StarAnimation.swift (Sources/Private/CoreAnimation/Animations/CustomPathAnimation.swift)
• Change coupling: GradientAnimations.swift ↔ StarAnimation.swift (Sources/Private/CoreAnimation/Animations/GradientAnimations.swift)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Further orphaned files (smaller)
• High CVE: [GHSA redacted] (Gemfile.lock)
• High CVE: [GHSA redacted] (Gemfile.lock)
• High CVE: [GHSA redacted] (Gemfile.lock)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 8 more

• BezierPath.roundCorners (cognitive 26) (Sources/Private/Utility/Primitives/BezierPath.swift)
• BezierPath.roundCorners (cyclomatic 18) (Sources/Private/Utility/Primitives/BezierPath.swift)
• BezierPath.star (cognitive 39) (Sources/Private/Utility/Primitives/BezierPath.swift)
• BezierPath.star (cyclomatic 20) (Sources/Private/Utility/Primitives/BezierPath.swift)
• BezierPath.trimPathAtLengths (cognitive 23) (Sources/Private/Utility/Primitives/BezierPath.swift)
• CALayer.setDebuggingState (cognitive 17) (Sources/Private/CoreAnimation/CoreAnimationLayer.swift)
• CGFloat.SolveCubic (cognitive 23) (Sources/Public/Keyframes/Interpolatable.swift)
• Change coupling: CoreAnimationLayer.swift ↔ MainThreadAnimationLayer.swift (Sources/Private/CoreAnimation/CoreAnimationLayer.swift)
• ClassTooLong: LottieAnimationLayer (Sources/Public/Animation/LottieAnimationLayer.swift)
• ClassTooLong: LottieAnimationView (Sources/Public/Animation/LottieAnimationView.swift)
• Collection.makeChangeset (cognitive 23) (Sources/Private/CoreAnimation/Layers/ShapeLayer.swift)
• Collection.resolveTrackMattes (cognitive 17) (Sources/Private/CoreAnimation/Layers/ShapeLayer.swift)
• CompoundBezierPath.trim (cognitive 39) (Sources/Private/Utility/Primitives/CompoundBezierPath.swift)
• CompoundBezierPath.trim (cyclomatic 24) (Sources/Private/Utility/Primitives/CompoundBezierPath.swift)
• Concentrated knowledge decay
• CoreTextRenderLayer.draw (cognitive 19) (Sources/Private/MainThread/LayerContainers/Utility/CoreTextRenderLayer.swift)
• CoreTextRenderLayer.draw (cyclomatic 17) (Sources/Private/MainThread/LayerContainers/Utility/CoreTextRenderLayer.swift)
• CoreTextRenderLayer.updateTextContent (cognitive 31) (Sources/Private/MainThread/LayerContainers/Utility/CoreTextRenderLayer.swift)
• CoreTextRenderLayer.updateTextContent (cyclomatic 23) (Sources/Private/MainThread/LayerContainers/Utility/CoreTextRenderLayer.swift)
• Coverage not measured — Swift suite
• …and 154 more

• 2 commits — 2 feature/other, 0 fixes

• Sources/Private — 1 commit
• Tests/Snapshots — 1 commit

• change: Don't attempt to decode Base64 images that exceed available process memory (#2700)
• change: Resolve track mattes referenced by tp (#2704)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

airbnb/lottie-ios was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.