AnimationKeypath("Progress.Time Remap") ValueProvider works with .mainThread but not with .automatic

[Swiggy-Asmi]

Hi,
I am seeing different behavior for a ValueProvider based on the rendering engine.

What I am trying to do
Apply a FloatValueProvider to the keypath "Progress.Time Remap" to affect the animation timing.
Keypath: "Progress.Time Remap"
Provider: FloatValueProvider(CGFloat(2))

SwiftUI
.valueProvider( FloatValueProvider(CGFloat(2)), for: AnimationKeypath(keypath: "Progress.Time Remap"))

Expected behavior
The time remap should update (animation timing changes as expected).

Actual behavior
When LottieConfiguration.shared.renderingEngine = .mainThread, it works.
When LottieConfiguration.shared.renderingEngine = .automatic, it does not work (the value provider appears ignored / no visible effect, lottie plays till end).

Configuration
LottieConfiguration.shared.renderingEngine = .automatic
LottieConfiguration.shared.decodingStrategy = .dictionaryBased

Questions
Is "Progress.Time Remap" supported with the .automatic engine and/or dictionaryBased decoding?
If not, is there an alternative supported approach for time remap in automatic mode?
If it should work, is this a known bug/regression?

Environment
Lottie iOS version: 4.5.2
iOS version(s): iOS 26
Device(s): iPhone 17
Animation format: dotLottie

[Swiggy-Asmi]

@calda can you help here?

[calda]

Time remapping is not customizable via value providers in the Core Animation rendering engine. Would be reasonable to add. PRs welcome!

If you're just trying to set the speed to 2x, you can more simply set the animationSpeed.

[Swiggy-Asmi]

Thank you for the clarification! In my use case, I have a Lottie animation with a progress bar. Based on user behavior, I was planning to dynamically increase/decrease the progress bar animation. Would you suggest any alternative approaches to achieve this?

[AyoubTadlaoui]

Since you're looking to dynamically control a progress bar animation based on user behavior, here are the recommended
approaches that work with .automatic rendering engine:

Option 1: Direct Progress Control (Recommended for Progress Bars)

Instead of time remapping, control the animation's progress directly:

SwiftUI:
struct ProgressBarView: View {
@State private var progress: AnimationProgressTime = 0.0

  var body: some View {                                                                                               
      LottieView(animation: .named("progress_bar"))                                                                   
          .currentProgress(progress)                                                                                  
          .frame(height: 50)                                                                                          
                                                                                                                      
      Slider(value: $progress, in: 0...1)                                                                             
  }                                                                                                                   

}

UIKit:
// Set progress directly (0.0 to 1.0)
animationView.currentProgress = userProgress // e.g., 0.75 for 75%

// Or animate to a progress value
animationView.play(fromProgress: currentProgress, toProgress: targetProgress, loopMode: .playOnce)

Option 2: Frame-Based Control

If your animation has specific frames for progress states:

// Play from frame 0 to frame 30 (out of 60 total)
animationView.play(fromFrame: 0, toFrame: AnimationFrameTime(30), loopMode: .playOnce)

Option 3: Marker-Based Control

If you've set up markers in your Lottie file (After Effects):

// Play between named markers
animationView.play(fromMarker: "start", toMarker: "halfway")

For Your Use Case

Since you want to dynamically increase/decrease based on user behavior:

struct DynamicProgressBar: View {
@binding var userProgress: Double // 0.0 to 1.0

  var body: some View {                                                                                               
      LottieView(animation: .named("progress_bar"))                                                                   
          .currentProgress(AnimationProgressTime(userProgress))                                                       
          .configure { view in                                                                                        
              view.contentMode = .scaleAspectFit                                                                      
          }                                                                                                           
  }                                                                                                                   

}

This approach works with .automatic (Core Animation) engine, requires no time remap, and gives you direct control over
the progress state that updates in real-time based on user actions.

Key insight: Treat the animation timeline as your progress scale (0.0 = empty, 1.0 = full) rather than trying to control
playback speed.