diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index a39590c..4b63983 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -47,6 +47,7 @@
 import com.android.tools.r8.ir.desugar.CfClassSynthesizerDesugaringEventConsumer;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAmender;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.PrefixRewritingNamingLens;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.R8LibraryDesugaring;
 import com.android.tools.r8.ir.desugar.itf.InterfaceMethodRewriter;
 import com.android.tools.r8.ir.desugar.records.RecordFieldValuesRewriter;
 import com.android.tools.r8.ir.desugar.records.RecordInstructionDesugaring;
@@ -729,6 +730,8 @@
 
       new NonStartupInStartupOutliner(appView).runIfNecessary(executorService, timing);
 
+      R8LibraryDesugaring.runIfNecessary(appView, executorService, timing);
+
       if (appView.appInfo().hasLiveness()) {
         SyntheticFinalization.finalizeWithLiveness(appView.withLiveness(), executorService, timing);
       } else {
diff --git a/src/main/java/com/android/tools/r8/graph/lens/MethodLookupResult.java b/src/main/java/com/android/tools/r8/graph/lens/MethodLookupResult.java
index f58004e..23eb2e1 100644
--- a/src/main/java/com/android/tools/r8/graph/lens/MethodLookupResult.java
+++ b/src/main/java/com/android/tools/r8/graph/lens/MethodLookupResult.java
@@ -7,6 +7,7 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.proto.RewrittenPrototypeDescription;
 import com.android.tools.r8.ir.code.InvokeType;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.R8LibraryDesugaringGraphLens;
 import com.android.tools.r8.optimize.bridgehoisting.BridgeHoistingLens;
 import com.android.tools.r8.utils.OptionalBool;
 
@@ -20,6 +21,7 @@
 public class MethodLookupResult extends MemberLookupResult<DexMethod> {
 
   private final OptionalBool isInterface;
+  private final boolean needsDesugaredLibraryApiConversion;
   private final InvokeType type;
   private final RewrittenPrototypeDescription prototypeChanges;
 
@@ -27,10 +29,12 @@
       DexMethod reference,
       DexMethod reboundReference,
       OptionalBool isInterface,
+      boolean needsDesugaredLibraryApiConversion,
       InvokeType type,
       RewrittenPrototypeDescription prototypeChanges) {
     super(reference, reboundReference);
     this.isInterface = isInterface;
+    this.needsDesugaredLibraryApiConversion = needsDesugaredLibraryApiConversion;
     this.type = type;
     this.prototypeChanges = prototypeChanges;
   }
@@ -43,6 +47,10 @@
     return isInterface;
   }
 
+  public boolean isNeedsDesugaredLibraryApiConversionSet() {
+    return needsDesugaredLibraryApiConversion;
+  }
+
   public InvokeType getType() {
     return type;
   }
@@ -62,6 +70,7 @@
             || lens.isEnumUnboxerLens()
             || lens.isNumberUnboxerLens()
             || lens instanceof BridgeHoistingLens
+            || lens instanceof R8LibraryDesugaringGraphLens
         : lens;
     return this;
   }
@@ -72,6 +81,7 @@
     private final GraphLens codeLens;
 
     private OptionalBool isInterface = OptionalBool.UNKNOWN;
+    private boolean needsDesugaredLibraryApiConversion = false;
     private RewrittenPrototypeDescription prototypeChanges = RewrittenPrototypeDescription.none();
     private InvokeType type;
 
@@ -89,6 +99,11 @@
       return this;
     }
 
+    public Builder setNeedsDesugaredLibraryApiConversion() {
+      this.needsDesugaredLibraryApiConversion = true;
+      return this;
+    }
+
     public Builder setPrototypeChanges(RewrittenPrototypeDescription prototypeChanges) {
       this.prototypeChanges = prototypeChanges;
       return this;
@@ -101,7 +116,12 @@
 
     public MethodLookupResult build() {
       return new MethodLookupResult(
-              reference, reboundReference, isInterface, type, prototypeChanges)
+              reference,
+              reboundReference,
+              isInterface,
+              needsDesugaredLibraryApiConversion,
+              type,
+              prototypeChanges)
           .verify(lens, codeLens);
     }
 
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
index 9f294ee..b8ef523 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
@@ -119,6 +119,15 @@
         appView, profileCollectionAdditions, eventConsumer);
   }
 
+  public static CfInstructionDesugaringEventConsumer createForR8LirToLirLibraryDesugaring(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      ProfileCollectionAdditions profileCollectionAdditions) {
+    CfInstructionDesugaringEventConsumer eventConsumer =
+        new R8LibraryDesugaringCfInstructionDesugaringEventConsumer();
+    return ProfileRewritingCfInstructionDesugaringEventConsumer.attach(
+        appView, profileCollectionAdditions, eventConsumer);
+  }
+
   public abstract List<ProgramMethod> finalizeDesugaring();
 
   public abstract boolean verifyNothingToFinalize();
@@ -851,4 +860,268 @@
       // Intentionally empty. The method will be hit by tracing if required.
     }
   }
+
+  public static class R8LibraryDesugaringCfInstructionDesugaringEventConsumer
+      extends CfInstructionDesugaringEventConsumer {
+
+    private R8LibraryDesugaringCfInstructionDesugaringEventConsumer() {}
+
+    @Override
+    public void acceptAPIConversionOutline(ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptClasspathEmulatedInterface(DexClasspathClass clazz) {
+      assert false;
+    }
+
+    @Override
+    public void acceptCollectionConversion(ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptConstantDynamicRewrittenBootstrapMethod(
+        ProgramMethod method, DexMethod oldSignature) {
+      assert false;
+    }
+
+    @Override
+    public void acceptCovariantRetargetMethod(ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptDesugaredLibraryRetargeterDispatchClasspathClass(DexClasspathClass clazz) {
+      assert false;
+    }
+
+    @Override
+    public void acceptEnumConversionClasspathClass(DexClasspathClass clazz) {
+      assert false;
+    }
+
+    @Override
+    public void acceptGenericApiConversionStub(DexClasspathClass clazz) {
+      assert false;
+    }
+
+    @Override
+    public void acceptWrapperClasspathClass(DexClasspathClass clazz) {
+      assert false;
+    }
+
+    @Override
+    public List<ProgramMethod> finalizeDesugaring() {
+      assert false;
+      return Collections.emptyList();
+    }
+
+    @Override
+    public boolean verifyNothingToFinalize() {
+      assert false;
+      return true;
+    }
+
+    @Override
+    public void acceptOutlinedMethod(ProgramMethod outlinedMethod, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptBackportedMethod(ProgramMethod backportedMethod, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptBackportedClass(DexProgramClass backportedClass, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptConstantDynamicClass(
+        ConstantDynamicClass constantDynamicClass, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptAutoCloseableDispatchMethod(ProgramMethod method, ProgramDefinition context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptAutoCloseableForwardingMethod(
+        ProgramMethod method, ProgramDefinition context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptDesugaredLibraryBridge(ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptInvokeSpecialBridgeInfo(InvokeSpecialBridgeInfo info) {
+      assert false;
+    }
+
+    @Override
+    public void acceptCompanionClassClinit(ProgramMethod method, ProgramMethod companionMethod) {
+      assert false;
+    }
+
+    @Override
+    public void acceptDefaultAsCompanionMethod(
+        ProgramMethod method, ProgramMethod companionMethod) {
+      assert false;
+    }
+
+    @Override
+    public void acceptPrivateAsCompanionMethod(
+        ProgramMethod method, ProgramMethod companionMethod) {
+      assert false;
+    }
+
+    @Override
+    public void acceptStaticAsCompanionMethod(ProgramMethod method, ProgramMethod companionMethod) {
+      assert false;
+    }
+
+    @Override
+    public void acceptInvokeStaticInterfaceOutliningMethod(
+        ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptInvokeObjectCloneOutliningMethod(
+        ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptLambdaClass(LambdaClass lambdaClass, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptNestConstructorBridge(
+        ProgramMethod target,
+        ProgramMethod bridge,
+        DexClass argumentClass,
+        DexClassAndMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptNestFieldGetBridge(
+        ProgramField target, ProgramMethod bridge, DexClassAndMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptNestFieldPutBridge(
+        ProgramField target, ProgramMethod bridge, DexClassAndMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptNestMethodBridge(
+        ProgramMethod target, ProgramMethod bridge, DexClassAndMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptRecordClass(DexProgramClass recordTagClass) {
+      assert false;
+    }
+
+    @Override
+    public void acceptRecordClassContext(DexProgramClass recordTagClass, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptRecordEqualsHelperMethod(ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptRecordGetFieldsAsObjectsHelperMethod(
+        ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptRecordHashCodeHelperMethod(ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptRecordToStringHelperMethod(ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptTwrCloseResourceMethod(ProgramMethod closeMethod, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptTypeSwitchMethod(ProgramMethod typeSwitchMethod, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptTypeSwitchClass(DexProgramClass typeSwitchClass, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptVarHandleDesugaringClass(DexProgramClass clazz) {
+      assert false;
+    }
+
+    @Override
+    public void acceptVarHandleDesugaringClassContext(
+        DexProgramClass clazz, ProgramDefinition context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptUtilityToStringIfNotNullMethod(ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptUtilityThrowClassCastExceptionIfNotNullMethod(
+        ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptUtilityThrowIllegalAccessErrorMethod(
+        ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptUtilityThrowIncompatibleClassChangeErrorMethod(
+        ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptUtilityThrowNoSuchMethodErrorMethod(
+        ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptUtilityThrowRuntimeExceptionWithMessageMethod(
+        ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java
index 22b75bb..996a13a 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringCollection.java
@@ -3,6 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.desugar;
 
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexProgramClass;
@@ -36,6 +38,13 @@
     return empty();
   }
 
+  @SuppressWarnings("DoNotCallSuggester")
+  public static CfPostProcessingDesugaringCollection createForR8LirToLirLibraryDesugaring(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      InterfaceMethodProcessorFacade interfaceDesugaring) {
+    throw new Unreachable();
+  }
+
   static CfPostProcessingDesugaringCollection empty() {
     return EmptyCfPostProcessingDesugaringCollection.getInstance();
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java
index e1a3cd9..2c8e392 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfPostProcessingDesugaringEventConsumer.java
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.ir.desugar;
 
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexClass;
 import com.android.tools.r8.graph.DexClassAndMethod;
@@ -63,6 +64,15 @@
         appView, profileCollectionAdditions, eventConsumer);
   }
 
+  public static CfPostProcessingDesugaringEventConsumer createForR8LirToLirLibraryDesugaring(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      ProfileCollectionAdditions profileCollectionAdditions) {
+    CfPostProcessingDesugaringEventConsumer eventConsumer =
+        new R8LibraryDesugaringPostProcessingDesugaringEventConsumer();
+    return ProfileRewritingCfPostProcessingDesugaringEventConsumer.attach(
+        appView, profileCollectionAdditions, eventConsumer);
+  }
+
   public abstract Set<DexMethod> getNewlyLiveMethods();
 
   public abstract void finalizeDesugaring() throws ExecutionException;
@@ -309,4 +319,109 @@
       additions.addLiveMethod(method);
     }
   }
+
+  public static class R8LibraryDesugaringPostProcessingDesugaringEventConsumer
+      extends CfPostProcessingDesugaringEventConsumer {
+
+    private R8LibraryDesugaringPostProcessingDesugaringEventConsumer() {}
+
+    @Override
+    public void acceptAPIConversionCallback(
+        ProgramMethod callbackMethod, ProgramMethod convertedMethod) {
+      assert false;
+    }
+
+    @Override
+    public void acceptDesugaredLibraryRetargeterDispatchClasspathClass(DexClasspathClass clazz) {
+      assert false;
+    }
+
+    @Override
+    public void acceptDesugaredLibraryRetargeterForwardingMethod(
+        ProgramMethod method, EmulatedDispatchMethodDescriptor descriptor) {
+      assert false;
+    }
+
+    @Override
+    public void acceptEmulatedInterfaceMarkerInterface(
+        DexProgramClass clazz, DexClasspathClass newInterface) {
+      assert false;
+    }
+
+    @Override
+    public void acceptInterfaceInjection(DexProgramClass clazz, DexClass newInterface) {
+      assert false;
+    }
+
+    @Override
+    public void acceptInterfaceMethodDesugaringForwardingMethod(
+        ProgramMethod method, DexClassAndMethod baseMethod) {
+      assert false;
+    }
+
+    @Override
+    public void acceptWrapperClasspathClass(DexClasspathClass clazz) {
+      assert false;
+    }
+
+    @Override
+    public Set<DexMethod> getNewlyLiveMethods() {
+      assert false;
+      return Collections.emptySet();
+    }
+
+    @Override
+    public void finalizeDesugaring() {
+      assert false;
+    }
+
+    @Override
+    public void warnMissingInterface(
+        DexProgramClass context, DexType missing, InterfaceDesugaringSyntheticHelper helper) {
+      assert false;
+    }
+
+    @Override
+    public void acceptCollectionConversion(ProgramMethod arrayConversion, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptEnumConversionClasspathClass(DexClasspathClass clazz) {
+      assert false;
+    }
+
+    @Override
+    public void acceptGenericApiConversionStub(DexClasspathClass dexClasspathClass) {
+      assert false;
+    }
+
+    @Override
+    public void acceptAutoCloseableDispatchMethod(ProgramMethod method, ProgramDefinition context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptAutoCloseableForwardingMethod(
+        ProgramMethod method, ProgramDefinition context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptAutoCloseableInterfaceInjection(
+        DexProgramClass clazz, DexClass newInterface) {
+      assert false;
+    }
+
+    @Override
+    public void acceptCovariantRetargetMethod(ProgramMethod method, ProgramMethod context) {
+      assert false;
+    }
+
+    @Override
+    public void acceptThrowingMethod(
+        ProgramMethod method, DexType errorType, FailedResolutionResult resolutionResult) {
+      assert false;
+    }
+  }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/LibraryDesugaringOptions.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/LibraryDesugaringOptions.java
index b350cb3..bfc67df 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/LibraryDesugaringOptions.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/LibraryDesugaringOptions.java
@@ -70,10 +70,18 @@
     return machineDesugaredLibrarySpecification.isLibraryCompilation();
   }
 
+  public boolean isEnabled() {
+    return !machineDesugaredLibrarySpecification.isEmpty();
+  }
+
   public boolean isL8() {
     return !synthesizedClassPrefix.isEmpty();
   }
 
+  public boolean isR8LirToLirLibraryDesugaringEnabled() {
+    return options.partialSubCompilationConfiguration != null;
+  }
+
   public void resetDesugaredLibrarySpecificationForTesting() {
     loadMachineDesugaredLibrarySpecification = null;
     machineDesugaredLibrarySpecification = DesugaredLibrarySpecification.empty();
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/R8LibraryDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/R8LibraryDesugaring.java
new file mode 100644
index 0000000..915fe93
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/R8LibraryDesugaring.java
@@ -0,0 +1,173 @@
+// Copyright (c) 2025, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.desugar.desugaredlibrary;
+
+import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
+import com.android.tools.r8.contexts.CompilationContext.ProcessorContext;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.Code;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.bytecodemetadata.BytecodeMetadataProvider;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.conversion.IRFinalizer;
+import com.android.tools.r8.ir.conversion.LensCodeRewriterUtils;
+import com.android.tools.r8.ir.conversion.LirConverter;
+import com.android.tools.r8.ir.conversion.MethodConversionOptions;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.CfPostProcessingDesugaringCollection;
+import com.android.tools.r8.ir.desugar.CfPostProcessingDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.itf.InterfaceMethodProcessorFacade;
+import com.android.tools.r8.ir.optimize.DeadCodeRemover;
+import com.android.tools.r8.profile.rewriting.ProfileCollectionAdditions;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.Timing;
+import com.android.tools.r8.utils.collections.ProgramMethodSet;
+import com.android.tools.r8.utils.collections.ProgramMethodSet.ConcurrentProgramMethodSet;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+public class R8LibraryDesugaring {
+
+  private final AppView<? extends AppInfoWithClassHierarchy> appView;
+  private final InternalOptions options;
+
+  public R8LibraryDesugaring(AppView<? extends AppInfoWithClassHierarchy> appView) {
+    this.appView = appView;
+    this.options = appView.options();
+  }
+
+  public static void runIfNecessary(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      ExecutorService executorService,
+      Timing timing)
+      throws ExecutionException {
+    InternalOptions options = appView.options();
+    if (options.isDesugaring()
+        && options.getLibraryDesugaringOptions().isEnabled()
+        && options.getLibraryDesugaringOptions().isR8LirToLirLibraryDesugaringEnabled()
+        && options.isGeneratingDex()) {
+      new R8LibraryDesugaring(appView).run(executorService, timing);
+    }
+  }
+
+  private void run(ExecutorService executorService, Timing timing) throws ExecutionException {
+    // Bring the LIR up-to-date.
+    LirConverter.rewriteLirWithLens(appView, timing, executorService);
+
+    // In R8 partial, commit the D8 classes to the app so that they will also be subject to library
+    // desugaring.
+    partialSubCompilationSetup();
+
+    // Apply library desugaring.
+    ProfileCollectionAdditions profileCollectionAdditions =
+        ProfileCollectionAdditions.create(appView);
+    ConcurrentProgramMethodSet synthesizedMethods = ProgramMethodSet.createConcurrent();
+    runInstructionDesugaring(profileCollectionAdditions, synthesizedMethods, executorService);
+    runPostProcessingDesugaring(
+        profileCollectionAdditions, synthesizedMethods, executorService, timing);
+
+    // Commit profile updates and convert synthesized methods to DEX.
+    profileCollectionAdditions.commit(appView);
+    processSynthesizedMethods(synthesizedMethods, executorService);
+
+    // In R8 partial, uncommit the D8 classes from the app so that they will not be subject to whole
+    // program optimizations.
+    partialSubCompilationTearDown();
+
+    assert !appView.getSyntheticItems().hasPendingSyntheticClasses();
+  }
+
+  @SuppressWarnings("UnusedVariable")
+  private void runInstructionDesugaring(
+      ProfileCollectionAdditions profileCollectionAdditions,
+      ConcurrentProgramMethodSet synthesizedMethods,
+      ExecutorService executorService)
+      throws ExecutionException {
+    ProcessorContext processorContext = appView.createProcessorContext();
+    CfInstructionDesugaringEventConsumer eventConsumer =
+        CfInstructionDesugaringEventConsumer.createForR8LirToLirLibraryDesugaring(
+            appView, profileCollectionAdditions);
+    LensCodeRewriterUtils emptyRewriterUtils = LensCodeRewriterUtils.empty();
+    ThreadUtils.processItems(
+        appView.appInfo().classes(),
+        clazz ->
+            clazz.forEachProgramMethodMatching(
+                method -> method.hasCode() && method.getCode().isLirCode(),
+                method -> {
+                  MethodProcessingContext methodProcessingContext =
+                      processorContext.createMethodProcessingContext(method);
+                  R8LibraryDesugaringGraphLens libraryDesugaringGraphLens =
+                      new R8LibraryDesugaringGraphLens(
+                          appView, eventConsumer, method, methodProcessingContext);
+                  LirConverter.rewriteLirMethodWithLens(
+                      method, appView, libraryDesugaringGraphLens, emptyRewriterUtils);
+                }),
+        options.getThreadingModule(),
+        executorService);
+    appView.dexItemFactory().clearTypeElementsCache();
+
+    // Move the pending methods and mark them live and ready for tracing.
+    List<ProgramMethod> needsProcessing = eventConsumer.finalizeDesugaring();
+    assert needsProcessing.isEmpty();
+
+    // TODO(b/391572031): Generate desugared library API tracking warnings.
+
+    // Commit pending synthetics.
+    appView.rebuildAppInfo();
+  }
+
+  @SuppressWarnings("UnusedVariable")
+  private void runPostProcessingDesugaring(
+      ProfileCollectionAdditions profileCollectionAdditions,
+      ConcurrentProgramMethodSet synthesizedMethods,
+      ExecutorService executorService,
+      Timing timing)
+      throws ExecutionException {
+    CfPostProcessingDesugaringEventConsumer eventConsumer =
+        CfPostProcessingDesugaringEventConsumer.createForR8LirToLirLibraryDesugaring(
+            appView, profileCollectionAdditions);
+    InterfaceMethodProcessorFacade interfaceDesugaring =
+        InterfaceMethodProcessorFacade.createForR8LirToLirLibraryDesugaring();
+    CfPostProcessingDesugaringCollection.createForR8LirToLirLibraryDesugaring(
+            appView, interfaceDesugaring)
+        .postProcessingDesugaring(
+            appView.appInfo().classes(), eventConsumer, executorService, timing);
+
+    // Commit pending synthetics.
+    appView.rebuildAppInfo();
+  }
+
+  private void processSynthesizedMethods(
+      ProgramMethodSet synthesizedMethods, ExecutorService executorService)
+      throws ExecutionException {
+    ThreadUtils.processItems(
+        synthesizedMethods,
+        method -> {
+          IRCode code = method.buildIR(appView, MethodConversionOptions.forLirPhase(appView));
+          DeadCodeRemover deadCodeRemover = new DeadCodeRemover(appView);
+          IRFinalizer<?> finalizer =
+              code.getConversionOptions().getFinalizer(deadCodeRemover, appView);
+          Code lirCode =
+              finalizer.finalizeCode(code, BytecodeMetadataProvider.empty(), Timing.empty());
+          method.setCode(lirCode, appView);
+        },
+        options.getThreadingModule(),
+        executorService);
+  }
+
+  private void partialSubCompilationSetup() {
+    if (options.partialSubCompilationConfiguration != null) {
+      options.partialSubCompilationConfiguration.asR8().commitDexingOutputClasses(appView);
+    }
+  }
+
+  private void partialSubCompilationTearDown() {
+    if (options.partialSubCompilationConfiguration != null) {
+      options.partialSubCompilationConfiguration.asR8().uncommitDexingOutputClasses(appView);
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/R8LibraryDesugaringGraphLens.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/R8LibraryDesugaringGraphLens.java
new file mode 100644
index 0000000..25a7ae1
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/R8LibraryDesugaringGraphLens.java
@@ -0,0 +1,120 @@
+// Copyright (c) 2025, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.desugar.desugaredlibrary;
+
+import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
+import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.lens.DefaultNonIdentityGraphLens;
+import com.android.tools.r8.graph.lens.FieldLookupResult;
+import com.android.tools.r8.graph.lens.GraphLens;
+import com.android.tools.r8.graph.lens.MethodLookupResult;
+import com.android.tools.r8.graph.lens.NonIdentityGraphLens;
+import com.android.tools.r8.graph.proto.RewrittenPrototypeDescription;
+import com.android.tools.r8.ir.code.BasicBlock;
+import com.android.tools.r8.ir.code.BasicBlockInstructionListIterator;
+import com.android.tools.r8.ir.code.BasicBlockIterator;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.InvokeMethod;
+import com.android.tools.r8.ir.code.Phi;
+import com.android.tools.r8.ir.conversion.MethodProcessor;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
+import com.android.tools.r8.ir.optimize.CustomLensCodeRewriter;
+import java.util.Collections;
+import java.util.Set;
+
+public class R8LibraryDesugaringGraphLens extends DefaultNonIdentityGraphLens {
+
+  @SuppressWarnings("UnusedVariable")
+  private final CfInstructionDesugaringEventConsumer eventConsumer;
+
+  @SuppressWarnings("UnusedVariable")
+  private final ProgramMethod method;
+
+  @SuppressWarnings("UnusedVariable")
+  private final MethodProcessingContext methodProcessingContext;
+
+  public R8LibraryDesugaringGraphLens(
+      AppView<? extends AppInfoWithClassHierarchy> appView,
+      CfInstructionDesugaringEventConsumer eventConsumer,
+      ProgramMethod method,
+      MethodProcessingContext methodProcessingContext) {
+    super(appView);
+    this.eventConsumer = eventConsumer;
+    this.method = method;
+    this.methodProcessingContext = methodProcessingContext;
+  }
+
+  @Override
+  public boolean hasCustomLensCodeRewriter() {
+    return true;
+  }
+
+  @Override
+  public CustomLensCodeRewriter getCustomLensCodeRewriter() {
+    return new R8LibraryDesugaringLensCodeRewriter();
+  }
+
+  @Override
+  protected FieldLookupResult internalDescribeLookupField(FieldLookupResult previous) {
+    // TODO(b/391572031): Implement field access desugaring.
+    return previous;
+  }
+
+  @Override
+  protected MethodLookupResult internalDescribeLookupMethod(
+      MethodLookupResult previous, DexMethod context, GraphLens codeLens) {
+    // TODO(b/391572031): Implement invoke desugaring.
+    assert previous.getPrototypeChanges().isEmpty();
+    return previous;
+  }
+
+  private class R8LibraryDesugaringLensCodeRewriter implements CustomLensCodeRewriter {
+
+    @Override
+    public Set<Phi> rewriteCode(
+        IRCode code,
+        MethodProcessor methodProcessor,
+        RewrittenPrototypeDescription prototypeChanges,
+        NonIdentityGraphLens lens) {
+      boolean changed = false;
+      BasicBlockIterator blocks = code.listIterator();
+      GraphLens codeLens = code.context().getDefinition().getCode().getCodeLens(appView);
+      while (blocks.hasNext()) {
+        BasicBlock block = blocks.next();
+        BasicBlockInstructionListIterator instructions = block.listIterator();
+        while (instructions.hasNext()) {
+          InvokeMethod invoke = instructions.next().asInvokeMethod();
+          if (invoke == null) {
+            continue;
+          }
+          MethodLookupResult lookupResult =
+              lookupMethod(
+                  invoke.getInvokedMethod(),
+                  code.context().getReference(),
+                  invoke.getType(),
+                  codeLens,
+                  invoke.getInterfaceBit());
+          if (lookupResult.isNeedsDesugaredLibraryApiConversionSet()) {
+            rewriteInvoke(code, blocks, instructions, invoke);
+          }
+          changed = true;
+        }
+      }
+      assert changed;
+      return Collections.emptySet();
+    }
+
+    @SuppressWarnings("UnusedVariable")
+    private void rewriteInvoke(
+        IRCode code,
+        BasicBlockIterator blocks,
+        BasicBlockInstructionListIterator instructions,
+        InvokeMethod invoke) {
+      // TODO(b/): Implement IR-to-IR invoke desugaring.
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodProcessorFacade.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodProcessorFacade.java
index 7e29629..fe8e567 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodProcessorFacade.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodProcessorFacade.java
@@ -6,6 +6,7 @@
 
 import static com.google.common.base.Predicates.alwaysTrue;
 
+import com.android.tools.r8.errors.Unreachable;
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.ProgramMethod;
@@ -44,6 +45,11 @@
     this.classProcessor = new ClassProcessor(appView, isLiveMethod, desugaringMode);
   }
 
+  @SuppressWarnings("DoNotCallSuggester")
+  public static InterfaceMethodProcessorFacade createForR8LirToLirLibraryDesugaring() {
+    throw new Unreachable();
+  }
+
   private boolean shouldProcess(DexProgramClass clazz) {
     return !appView.isAlreadyLibraryDesugared(clazz) && !clazz.originatesFromDexResource();
   }
diff --git a/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java b/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
index eb4ec46..34718c2 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
@@ -32,6 +32,7 @@
 import com.android.tools.r8.ir.conversion.LensCodeRewriterUtils;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions;
 import com.android.tools.r8.ir.conversion.MethodProcessor;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.R8LibraryDesugaringGraphLens;
 import com.android.tools.r8.ir.optimize.AffectedValues;
 import com.android.tools.r8.ir.optimize.DeadCodeRemover;
 import com.android.tools.r8.lightir.LirBuilder.NameComputationPayload;
@@ -180,6 +181,13 @@
         }
       }
     }
+    if (graphLens instanceof R8LibraryDesugaringGraphLens) {
+      if (result.isNeedsDesugaredLibraryApiConversionSet()) {
+        return true;
+      }
+    } else {
+      assert !result.isNeedsDesugaredLibraryApiConversionSet();
+    }
     assert result.getPrototypeChanges().isEmpty();
     return false;
   }
diff --git a/src/main/java/com/android/tools/r8/partial/R8PartialSubCompilationConfiguration.java b/src/main/java/com/android/tools/r8/partial/R8PartialSubCompilationConfiguration.java
index 36a4f6b..5e82a63 100644
--- a/src/main/java/com/android/tools/r8/partial/R8PartialSubCompilationConfiguration.java
+++ b/src/main/java/com/android/tools/r8/partial/R8PartialSubCompilationConfiguration.java
@@ -248,6 +248,23 @@
       assert amendMissingClasses(appView);
     }
 
+    public void uncommitDexingOutputClasses(AppView<? extends AppInfoWithClassHierarchy> appView) {
+      List<DexClasspathClass> newClasspathClasses =
+          ListUtils.sort(
+              DexClasspathClass.toClasspathClasses(dexingOutputClasses.values()).values(),
+              Comparator.comparing(DexClass::getType));
+      DirectMappedDexApplication newApp =
+          appView
+              .app()
+              .asDirect()
+              .builder()
+              .removeProgramClasses(clazz -> dexingOutputClasses.containsKey(clazz.getType()))
+              .addClasspathClasses(newClasspathClasses)
+              .build();
+      appView.rebuildAppInfo(newApp);
+      assert amendMissingClasses(appView);
+    }
+
     public boolean hasD8DefinitionFor(DexReference reference) {
       if (reference.isDexType()) {
         return dexingOutputClasses.containsKey(reference.asDexType());