diff --git a/src/main/java/com/android/tools/r8/cf/code/CfFieldInstruction.java b/src/main/java/com/android/tools/r8/cf/code/CfFieldInstruction.java
index cd8d6b7..14c62be 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfFieldInstruction.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfFieldInstruction.java
@@ -57,6 +57,13 @@
     return field;
   }
 
+  public CfFieldInstruction withField(DexField newField) {
+    if (field == newField) {
+      return this;
+    }
+    return new CfFieldInstruction(opcode, newField, newField);
+  }
+
   public int getOpcode() {
     return opcode;
   }
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
index 625430b..3237f29 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
@@ -77,6 +77,13 @@
     return method;
   }
 
+  public CfInvoke withMethod(DexMethod newMethod) {
+    if (method == newMethod) {
+      return this;
+    }
+    return new CfInvoke(opcode, newMethod, itf);
+  }
+
   public int getOpcode() {
     return opcode;
   }
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 9cc0945..af0ba94 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -1419,7 +1419,7 @@
     return new Builder(false);
   }
 
-  private static Builder builder(DexEncodedMethod from) {
+  public static Builder builder(DexEncodedMethod from) {
     return new Builder(from.isD8R8Synthesized(), from);
   }
 
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
index 5d49406..888707ff 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
@@ -53,9 +53,9 @@
       throws ExecutionException {
     List<DexProgramClass> classes = appView.appInfo().classes();
 
-      CfClassSynthesizerDesugaringEventConsumer classSynthesizerEventConsumer =
-          new CfClassSynthesizerDesugaringEventConsumer();
-      converter.classSynthesisDesugaring(executorService, classSynthesizerEventConsumer);
+    CfClassSynthesizerDesugaringEventConsumer classSynthesizerEventConsumer =
+        new CfClassSynthesizerDesugaringEventConsumer();
+    converter.classSynthesisDesugaring(executorService, classSynthesizerEventConsumer);
     if (!classSynthesizerEventConsumer.getSynthesizedClasses().isEmpty()) {
       classes =
           ImmutableList.<DexProgramClass>builder()
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfClassSynthesizerDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/CfClassSynthesizerDesugaringEventConsumer.java
index 3f60ffe..feb1b51 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfClassSynthesizerDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfClassSynthesizerDesugaringEventConsumer.java
@@ -4,8 +4,10 @@
 
 package com.android.tools.r8.ir.desugar;
 
+import com.android.tools.r8.graph.DexClasspathClass;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryRetargeterSynthesizerEventConsumer.DesugaredLibraryRetargeterL8SynthesizerEventConsumer;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryCustomConversionEventConsumer;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryL8ProgramWrapperSynthesizerEventConsumer;
 import com.android.tools.r8.ir.desugar.itf.EmulatedInterfaceSynthesizerEventConsumer.L8ProgramEmulatedInterfaceSynthesizerEventConsumer;
 import com.android.tools.r8.ir.desugar.records.RecordDesugaringEventConsumer;
@@ -16,6 +18,7 @@
     implements L8ProgramEmulatedInterfaceSynthesizerEventConsumer,
         DesugaredLibraryL8ProgramWrapperSynthesizerEventConsumer,
         DesugaredLibraryRetargeterL8SynthesizerEventConsumer,
+        DesugaredLibraryCustomConversionEventConsumer,
         RecordDesugaringEventConsumer {
 
   private Set<DexProgramClass> synthesizedClasses = Sets.newConcurrentHashSet();
@@ -40,6 +43,11 @@
     synthesizedClasses.add(clazz);
   }
 
+  @Override
+  public void acceptCustomConversionClasspathClass(DexClasspathClass clazz) {
+    // Intentionally empty.
+  }
+
   public Set<DexProgramClass> getSynthesizedClasses() {
     return synthesizedClasses;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfCodeTypeRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/CfCodeTypeRewriter.java
new file mode 100644
index 0000000..8aa124c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfCodeTypeRewriter.java
@@ -0,0 +1,131 @@
+// Copyright (c) 2021, 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;
+
+import com.android.tools.r8.cf.code.CfFieldInstruction;
+import com.android.tools.r8.cf.code.CfFrame;
+import com.android.tools.r8.cf.code.CfFrame.FrameType;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.cf.code.CfTypeInstruction;
+import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.Code;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.utils.ListUtils;
+import it.unimi.dsi.fastutil.ints.Int2ReferenceAVLTreeMap;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Rewrites all references to a type in a CfCode instance to another type.
+ *
+ * <p>The implementation is minimal for the needs of DesugaredLibraryCustomConversionRewriter.
+ */
+public class CfCodeTypeRewriter {
+
+  private final DexItemFactory factory;
+
+  public CfCodeTypeRewriter(DexItemFactory factory) {
+    this.factory = factory;
+  }
+
+  public DexEncodedMethod rewriteCfCode(
+      DexEncodedMethod method, Map<DexType, DexType> replacement) {
+    if (method.getCode() == null) {
+      assert false;
+      return null;
+    }
+    return DexEncodedMethod.builder(method)
+        .setMethod(rewriteMethod(method.getReference(), replacement))
+        .setCode(rewriteCfCode(method.getCode(), replacement))
+        .build();
+  }
+
+  private Code rewriteCfCode(Code code, Map<DexType, DexType> replacement) {
+    assert code.isCfCode();
+    CfCode cfCode = code.asCfCode();
+    List<CfInstruction> desugaredInstructions =
+        ListUtils.map(
+            cfCode.getInstructions(),
+            instruction -> rewriteCfInstruction(instruction, replacement));
+    cfCode.setInstructions(desugaredInstructions);
+    return cfCode;
+  }
+
+  private CfInstruction rewriteCfInstruction(
+      CfInstruction instruction, Map<DexType, DexType> replacement) {
+    if (instruction.isInvoke()) {
+      CfInvoke cfInvoke = instruction.asInvoke();
+      DexMethod replacementMethod = rewriteMethod(cfInvoke.getMethod(), replacement);
+      return cfInvoke.withMethod(replacementMethod);
+    }
+    if (instruction.isTypeInstruction()) {
+      CfTypeInstruction typeInstruction = instruction.asTypeInstruction();
+      return typeInstruction.withType(rewriteType(typeInstruction.getType(), replacement));
+    }
+    if (instruction.isFieldInstruction()) {
+      CfFieldInstruction fieldInstruction = instruction.asFieldInstruction();
+      DexField field = rewriteField(fieldInstruction.getField(), replacement);
+      return fieldInstruction.withField(field);
+    }
+    if (instruction.isFrame()) {
+      CfFrame cfFrame = instruction.asFrame();
+      return rewriteFrame(cfFrame, replacement);
+    }
+    assert !instruction.isInvokeDynamic();
+    return instruction;
+  }
+
+  private CfFrame rewriteFrame(CfFrame cfFrame, Map<DexType, DexType> replacement) {
+    Int2ReferenceAVLTreeMap<FrameType> newLocals = new Int2ReferenceAVLTreeMap<>();
+    cfFrame
+        .getLocals()
+        .forEach((i, frameType) -> newLocals.put(i, rewriteFrameType(frameType, replacement)));
+    Deque<FrameType> newStack = new ArrayDeque<>();
+    cfFrame
+        .getStack()
+        .forEach(frameType -> newStack.addLast(rewriteFrameType(frameType, replacement)));
+    return new CfFrame(newLocals, newStack);
+  }
+
+  private FrameType rewriteFrameType(FrameType frameType, Map<DexType, DexType> replacement) {
+    if (frameType.isInitialized()) {
+      return FrameType.initialized(rewriteType(frameType.getInitializedType(), replacement));
+    }
+    if (frameType.isUninitializedNew()) {
+      FrameType.uninitializedNew(
+          frameType.getUninitializedLabel(),
+          rewriteType(frameType.getUninitializedNewType(), replacement));
+    }
+    return frameType;
+  }
+
+  private DexType rewriteType(DexType type, Map<DexType, DexType> replacement) {
+    return replacement.getOrDefault(type, type);
+  }
+
+  private DexField rewriteField(DexField field, Map<DexType, DexType> replacement) {
+    DexType newHolder = rewriteType(field.holder, replacement);
+    DexType newType = rewriteType(field.type, replacement);
+    return factory.createField(newHolder, newType, field.name);
+  }
+
+  private DexMethod rewriteMethod(DexMethod reference, Map<DexType, DexType> replacement) {
+    DexType newHolder = rewriteType(reference.holder, replacement);
+    DexType newReturnType = rewriteType(reference.getReturnType(), replacement);
+    DexType[] newParameters = new DexType[reference.getArity()];
+    for (int i = 0; i < reference.getArity(); i++) {
+      newParameters[i] = rewriteType(reference.getParameter(i), replacement);
+    }
+    return factory.createMethod(
+        newHolder, factory.createProto(newReturnType, newParameters), reference.getName());
+  }
+}
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 2493dd3..39d072a 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
@@ -100,6 +100,11 @@
       }
 
       @Override
+      public void acceptCustomConversionClasspathClass(DexClasspathClass clazz) {
+        assert false;
+      }
+
+      @Override
       public void acceptAPIConversion(ProgramMethod method) {
         assert false;
       }
@@ -282,6 +287,11 @@
     }
 
     @Override
+    public void acceptCustomConversionClasspathClass(DexClasspathClass clazz) {
+      // Intentionally empty.
+    }
+
+    @Override
     public void acceptAPIConversion(ProgramMethod method) {
       methodProcessor.scheduleDesugaredMethodForProcessing(method);
     }
@@ -436,6 +446,11 @@
     }
 
     @Override
+    public void acceptCustomConversionClasspathClass(DexClasspathClass clazz) {
+      additions.addLiveClasspathClass(clazz);
+    }
+
+    @Override
     public void acceptAPIConversion(ProgramMethod method) {
       // Intentionally empty. The method will be hit by tracing if required.
     }
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 8f5178e..486915a 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
@@ -118,6 +118,11 @@
     public void acceptWrapperClasspathClass(DexClasspathClass clazz) {
       // Intentionally empty.
     }
+
+    @Override
+    public void acceptCustomConversionClasspathClass(DexClasspathClass clazz) {
+      // Intentionally empty.
+    }
   }
 
   public static class R8PostProcessingDesugaringEventConsumer
@@ -191,5 +196,10 @@
     public void acceptWrapperClasspathClass(DexClasspathClass clazz) {
       additions.addLiveClasspathClass(clazz);
     }
+
+    @Override
+    public void acceptCustomConversionClasspathClass(DexClasspathClass clazz) {
+      additions.addLiveClasspathClass(clazz);
+    }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryCustomConversionRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryCustomConversionRewriter.java
new file mode 100644
index 0000000..2a800f8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryCustomConversionRewriter.java
@@ -0,0 +1,160 @@
+// Copyright (c) 2021, 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 static com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryAPIConverter.vivifiedTypeFor;
+import static com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryWrapperSynthesizer.conversionEncodedMethod;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.ir.desugar.CfClassSynthesizerDesugaring;
+import com.android.tools.r8.ir.desugar.CfClassSynthesizerDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.CfCodeTypeRewriter;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryCustomConversionEventConsumer;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Sets;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * L8 specific pass, rewrites or generates custom conversions.
+ *
+ * <p>In normal set-ups, custom conversions are provided with the types: type <-> rewrittenType.
+ * However the compiler uses internally the types: vivifiedType <-> type during compilation. This
+ * pass rewrites the custom conversions from type <-> rewrittenType to vivifiedType <-> type so the
+ * compilation can look-up and find the methods.
+ *
+ * <p>In broken set-ups, where the input is missing, instead generates the custom conversions on the
+ * classpath since they are assumed to be present in L8.
+ */
+public class DesugaredLibraryCustomConversionRewriter implements CfClassSynthesizerDesugaring {
+
+  private final AppView<?> appView;
+  private final DesugaredLibraryWrapperSynthesizer synthesizer;
+  private final DexString libraryPrefix;
+
+  public DesugaredLibraryCustomConversionRewriter(
+      AppView<?> appView, DesugaredLibraryWrapperSynthesizer synthesizer) {
+    assert appView.options().isDesugaredLibraryCompilation();
+    this.appView = appView;
+    this.synthesizer = synthesizer;
+    this.libraryPrefix =
+        appView
+            .dexItemFactory()
+            .createString(
+                "L"
+                    + appView
+                        .options()
+                        .desugaredLibraryConfiguration
+                        .getSynthesizedLibraryClassesPackagePrefix());
+  }
+
+  @Override
+  public void synthesizeClasses(CfClassSynthesizerDesugaringEventConsumer eventConsumer) {
+    Map<DexProgramClass, Set<DexEncodedMethod>> methodsToProcessPerClass =
+        readConversionMethodsToConvert(eventConsumer);
+    methodsToProcessPerClass.forEach(
+        (conversionHolder, conversionsMethods) -> {
+          Set<DexEncodedMethod> convertedMethods = convertMethods(conversionsMethods);
+          conversionHolder.getMethodCollection().removeMethods(conversionsMethods);
+          conversionHolder.addDirectMethods(convertedMethods);
+        });
+  }
+
+  private Map<DexProgramClass, Set<DexEncodedMethod>> readConversionMethodsToConvert(
+      DesugaredLibraryCustomConversionEventConsumer eventConsumer) {
+    Map<DexProgramClass, Set<DexEncodedMethod>> methodsToProcessPerClass = new IdentityHashMap<>();
+    appView
+        .options()
+        .desugaredLibraryConfiguration
+        .getCustomConversions()
+        .forEach(
+            (convertedType, conversionHolder) -> {
+              DexClass dexClass = appView.definitionFor(conversionHolder);
+              if (dexClass == null || dexClass.isNotProgramClass()) {
+                generateMissingConversion(eventConsumer, convertedType, conversionHolder);
+                return;
+              }
+              DexProgramClass conversionProgramClass = dexClass.asProgramClass();
+              DexType rewrittenType = appView.rewritePrefix.rewrittenType(convertedType, appView);
+              Set<DexEncodedMethod> methods =
+                  methodsToProcessPerClass.computeIfAbsent(
+                      conversionProgramClass, ignored -> Sets.newIdentityHashSet());
+              methods.add(
+                  conversionEncodedMethod(
+                      conversionProgramClass,
+                      rewrittenType,
+                      convertedType,
+                      appView.dexItemFactory()));
+              methods.add(
+                  conversionEncodedMethod(
+                      conversionProgramClass,
+                      convertedType,
+                      rewrittenType,
+                      appView.dexItemFactory()));
+            });
+    return methodsToProcessPerClass;
+  }
+
+  private void generateMissingConversion(
+      DesugaredLibraryCustomConversionEventConsumer eventConsumer,
+      DexType convertedType,
+      DexType conversionHolder) {
+    appView
+        .options()
+        .reporter
+        .warning(
+            "Missing custom conversion "
+                + conversionHolder
+                + " from L8 compilation: Cannot convert "
+                + convertedType);
+    DexType vivifiedType = vivifiedTypeFor(convertedType, appView);
+    synthesizer.ensureClasspathCustomConversion(
+        vivifiedType, convertedType, eventConsumer, conversionHolder);
+    synthesizer.ensureClasspathCustomConversion(
+        convertedType, vivifiedType, eventConsumer, conversionHolder);
+  }
+
+  private Set<DexEncodedMethod> convertMethods(Set<DexEncodedMethod> conversionsMethods) {
+    Set<DexEncodedMethod> newMethods = Sets.newIdentityHashSet();
+    CfCodeTypeRewriter cfCodeTypeRewriter = new CfCodeTypeRewriter(appView.dexItemFactory());
+    for (DexEncodedMethod conversionMethod : conversionsMethods) {
+      Map<DexType, DexType> replacement = computeReplacement(conversionMethod.getReference());
+      newMethods.add(cfCodeTypeRewriter.rewriteCfCode(conversionMethod, replacement));
+    }
+    return newMethods;
+  }
+
+  private Map<DexType, DexType> computeReplacement(DexMethod reference) {
+    assert reference.getArity() == 1;
+    DexType argumentType = reference.getArgumentType(0, true);
+    if (isLibraryPrefixed(argumentType)) {
+      return ImmutableMap.of(
+          argumentType,
+          convertDesugaredLibraryToVivifiedType(argumentType, reference.getReturnType()));
+    }
+    assert isLibraryPrefixed(reference.getReturnType());
+    return ImmutableMap.of(
+        reference.getReturnType(),
+        convertDesugaredLibraryToVivifiedType(reference.getReturnType(), argumentType));
+  }
+
+  private boolean isLibraryPrefixed(DexType argumentType) {
+    return argumentType.getDescriptor().startsWith(libraryPrefix);
+  }
+
+  private DexType convertDesugaredLibraryToVivifiedType(DexType type, DexType oppositeType) {
+    if (!isLibraryPrefixed(type)) {
+      return type;
+    }
+    return vivifiedTypeFor(oppositeType, appView);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizer.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizer.java
index 126d020..a28f92a 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizer.java
@@ -11,6 +11,7 @@
 import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DexAnnotationSet;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexClassAndMethod;
 import com.android.tools.r8.graph.DexClasspathClass;
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
@@ -26,6 +27,7 @@
 import com.android.tools.r8.ir.desugar.CfClassSynthesizerDesugaring;
 import com.android.tools.r8.ir.desugar.CfClassSynthesizerDesugaringEventConsumer;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryClasspathWrapperSynthesizeEventConsumer;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryCustomConversionEventConsumer;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryL8ProgramWrapperSynthesizerEventConsumer;
 import com.android.tools.r8.ir.synthetic.DesugaredLibraryAPIConversionCfCodeProvider.APIConverterConstructorCfCodeProvider;
 import com.android.tools.r8.ir.synthetic.DesugaredLibraryAPIConversionCfCodeProvider.APIConverterThrowRuntimeExceptionCfCodeProvider;
@@ -124,13 +126,28 @@
       DexType srcType,
       DexType destType,
       DesugaredLibraryClasspathWrapperSynthesizeEventConsumer eventConsumer) {
-    DexMethod customConversion = getCustomConversion(type, srcType, destType);
-    if (customConversion != null) {
-      return customConversion;
+    if (hasCustomConversion(type)) {
+      return getCustomConversion(type, srcType, destType, eventConsumer);
     }
     assert canGenerateWrapper(type) : type;
-    DexClass clazz = getValidClassToWrap(type);
-    WrapperConversions wrapperConversions = ensureWrappers(clazz, eventConsumer);
+    WrapperConversions wrapperConversions =
+        ensureWrappers(getValidClassToWrap(type), eventConsumer);
+    return extractConversion(type, srcType, destType, wrapperConversions);
+  }
+
+  public DexMethod getExistingProgramConversionMethod(
+      DexType type, DexType srcType, DexType destType) {
+    if (hasCustomConversion(type)) {
+      return getExistingProgramCustomConversion(type, srcType, destType);
+    }
+    assert canGenerateWrapper(type) : type;
+    WrapperConversions wrapperConversions =
+        getExistingProgramWrapperConversions(getValidClassToWrap(type));
+    return extractConversion(type, srcType, destType, wrapperConversions);
+  }
+
+  private DexMethod extractConversion(
+      DexType type, DexType srcType, DexType destType, WrapperConversions wrapperConversions) {
     DexMethod conversion =
         type == srcType
             ? wrapperConversions.getConversion()
@@ -140,32 +157,80 @@
     return conversion;
   }
 
-  public DexMethod getExistingProgramConversionMethod(
-      DexType type, DexType srcType, DexType destType) {
-    DexMethod customConversion = getCustomConversion(type, srcType, destType);
-    if (customConversion != null) {
-      return customConversion;
-    }
-    WrapperConversions wrapperConversions =
-        getExistingProgramWrapperConversions(getValidClassToWrap(type));
-    DexMethod conversion =
-        type == srcType
-            ? wrapperConversions.getConversion()
-            : wrapperConversions.getVivifiedConversion();
-    assert srcType == conversion.getArgumentType(0, true);
-    return conversion;
+  private boolean hasCustomConversion(DexType type) {
+    return appView.options().desugaredLibraryConfiguration.getCustomConversions().get(type) != null;
   }
 
-  private DexMethod getCustomConversion(DexType type, DexType srcType, DexType destType) {
-    // ConversionType holds the methods "rewrittenType convert(type)" and the other way around.
-    // But everything is going to be rewritten, so we need to use vivifiedType and type".
+  private DexMethod getCustomConversion(
+      DexType type,
+      DexType srcType,
+      DexType destType,
+      DesugaredLibraryClasspathWrapperSynthesizeEventConsumer eventConsumer) {
+    assert hasCustomConversion(type);
     DexType conversionHolder =
         appView.options().desugaredLibraryConfiguration.getCustomConversions().get(type);
-    if (conversionHolder != null) {
-      return factory.createMethod(
-          conversionHolder, factory.createProto(destType, srcType), factory.convertMethodName);
+    assert conversionHolder != null;
+    DexClass dexClass = appView.definitionFor(conversionHolder);
+    if (dexClass != null && dexClass.isProgramClass()) {
+      return getExistingProgramCustomConversion(type, srcType, destType);
     }
-    return null;
+    return ensureClasspathCustomConversion(srcType, destType, eventConsumer, conversionHolder)
+        .getReference();
+  }
+
+  public DexClassAndMethod ensureClasspathCustomConversion(
+      DexType srcType,
+      DexType destType,
+      DesugaredLibraryCustomConversionEventConsumer eventConsumer,
+      DexType conversionHolder) {
+    return appView
+        .getSyntheticItems()
+        .ensureFixedClasspathClassFromTypeMethod(
+            factory.convertMethodName,
+            factory.createProto(destType, srcType),
+            SyntheticKind.CUSTOM_CONVERSION,
+            conversionHolder,
+            appView,
+            ignored -> {},
+            eventConsumer::acceptCustomConversionClasspathClass,
+            methodBuilder ->
+                methodBuilder
+                    .setAccessFlags(
+                        MethodAccessFlags.fromSharedAccessFlags(
+                            Constants.ACC_PUBLIC | Constants.ACC_STATIC, false))
+                    .setCode(null));
+  }
+
+  private DexMethod getExistingProgramCustomConversion(
+      DexType type, DexType srcType, DexType destType) {
+    assert hasCustomConversion(type);
+    DexType conversionHolder =
+        appView.options().desugaredLibraryConfiguration.getCustomConversions().get(type);
+    assert conversionHolder != null;
+    DexClass dexClass = appView.definitionFor(conversionHolder);
+    assert dexClass != null;
+    // Note: DexClass can unfortunately be a non program class on broken set-ups.
+    DexMethod conversionMethod =
+        conversionMethod(dexClass.type, srcType, destType, appView.dexItemFactory());
+    assert conversionEncodedMethod(dexClass, srcType, destType, appView.dexItemFactory())
+            .getReference()
+        == conversionMethod;
+    return conversionMethod;
+  }
+
+  public static DexEncodedMethod conversionEncodedMethod(
+      DexClass conversionHolder, DexType srcType, DexType destType, DexItemFactory factory) {
+    DexMethod method = conversionMethod(conversionHolder.type, srcType, destType, factory);
+    DexEncodedMethod conversionMethod = conversionHolder.lookupDirectMethod(method);
+    assert conversionMethod != null;
+    return conversionMethod;
+  }
+
+  private static DexMethod conversionMethod(
+      DexType conversionHolder, DexType srcType, DexType destType, DexItemFactory factory) {
+    DexProto proto = factory.createProto(destType, srcType);
+    DexMethod method = factory.createMethod(conversionHolder, proto, factory.convertMethodName);
+    return method;
   }
 
   private boolean canConvert(DexType type) {
@@ -276,10 +341,12 @@
   }
 
   private DexMethod getConversion(DexClass wrapper, DexType returnType, DexType argType) {
-    DexMethod convertMethod =
-        factory.createMethod(
-            wrapper.type, factory.createProto(returnType, argType), factory.convertMethodName);
-    return wrapper.lookupDirectMethod(convertMethod).getReference();
+    DexMethod conversionMethod =
+        conversionMethod(wrapper.type, argType, returnType, appView.dexItemFactory());
+    assert conversionEncodedMethod(wrapper, argType, returnType, appView.dexItemFactory())
+            .getReference()
+        == conversionMethod;
+    return conversionMethod;
   }
 
   private DexEncodedField getWrapperUniqueEncodedField(DexClass wrapper) {
@@ -630,6 +697,7 @@
   @Override
   public void synthesizeClasses(CfClassSynthesizerDesugaringEventConsumer eventConsumer) {
     DesugaredLibraryConfiguration conf = appView.options().desugaredLibraryConfiguration;
+    new DesugaredLibraryCustomConversionRewriter(appView, this).synthesizeClasses(eventConsumer);
     List<DexProgramClass> validClassesToWrap = new ArrayList<>();
     for (DexType type : conf.getWrapperConversions()) {
       assert !conf.getCustomConversions().containsKey(type);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizerEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizerEventConsumer.java
index 212ad66..a4a894d 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizerEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/DesugaredLibraryWrapperSynthesizerEventConsumer.java
@@ -15,7 +15,13 @@
     void acceptWrapperProgramClass(DexProgramClass clazz);
   }
 
-  interface DesugaredLibraryClasspathWrapperSynthesizeEventConsumer {
+  interface DesugaredLibraryCustomConversionEventConsumer {
+
+    void acceptCustomConversionClasspathClass(DexClasspathClass clazz);
+  }
+
+  interface DesugaredLibraryClasspathWrapperSynthesizeEventConsumer
+      extends DesugaredLibraryCustomConversionEventConsumer {
 
     void acceptWrapperClasspathClass(DexClasspathClass clazz);
   }
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java
index 7dc9de3..f136195 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/itf/InterfaceMethodRewriter.java
@@ -165,7 +165,6 @@
     DesugaredLibraryConfiguration config = options.desugaredLibraryConfiguration;
     BiConsumer<DexType, DexType> registerEntry = registerMapEntry(appInfo);
     config.getEmulateLibraryInterface().forEach(registerEntry);
-    config.getCustomConversions().forEach(registerEntry);
     config.getRetargetCoreLibMember().forEach((method, types) -> types.forEach(registerEntry));
   }
 
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
index 474d1c3..9e362ed 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -644,31 +644,86 @@
       AppView<?> appView,
       Consumer<SyntheticClasspathClassBuilder> classConsumer,
       Consumer<DexClasspathClass> onCreationConsumer) {
+    // Obtain the outer synthesizing context in the case the context itself is synthetic.
+    // This is to ensure a flat input-type -> synthetic-item mapping.
     SynthesizingContext outerContext = SynthesizingContext.fromNonSyntheticInputContext(context);
     DexType type = SyntheticNaming.createFixedType(kind, outerContext, appView.dexItemFactory());
+    return internalEnsureDexClasspathClass(
+        kind, classConsumer, onCreationConsumer, outerContext, type, appView);
+  }
+
+  private DexClasspathClass internalEnsureDexClasspathClass(
+      SyntheticKind kind,
+      Consumer<SyntheticClasspathClassBuilder> classConsumer,
+      Consumer<DexClasspathClass> onCreationConsumer,
+      SynthesizingContext outerContext,
+      DexType type,
+      AppView<?> appView) {
     DexClass dexClass = appView.appInfo().definitionForWithoutExistenceAssert(type);
     if (dexClass != null) {
       assert dexClass.isClasspathClass();
       return dexClass.asClasspathClass();
     }
-    synchronized (context) {
+    synchronized (type) {
       dexClass = appView.appInfo().definitionForWithoutExistenceAssert(type);
       if (dexClass != null) {
         assert dexClass.isClasspathClass();
         return dexClass.asClasspathClass();
       }
-      // Obtain the outer synthesizing context in the case the context itself is synthetic.
-      // This is to ensure a flat input-type -> synthetic-item mapping.
-      SyntheticClasspathClassBuilder classBuilder =
-          new SyntheticClasspathClassBuilder(type, kind, outerContext, appView.dexItemFactory());
-      classConsumer.accept(classBuilder);
-      DexClasspathClass clazz = classBuilder.build();
-      addPendingDefinition(new SyntheticClasspathClassDefinition(kind, outerContext, clazz));
+      DexClasspathClass clazz =
+          internalCreateClasspathClass(
+              kind, classConsumer, outerContext, type, appView.dexItemFactory());
       onCreationConsumer.accept(clazz);
       return clazz;
     }
   }
 
+  private DexClasspathClass internalCreateClasspathClass(
+      SyntheticKind kind,
+      Consumer<SyntheticClasspathClassBuilder> fn,
+      SynthesizingContext outerContext,
+      DexType type,
+      DexItemFactory factory) {
+    SyntheticClasspathClassBuilder classBuilder =
+        new SyntheticClasspathClassBuilder(type, kind, outerContext, factory);
+    fn.accept(classBuilder);
+      DexClasspathClass clazz = classBuilder.build();
+      addPendingDefinition(new SyntheticClasspathClassDefinition(kind, outerContext, clazz));
+      return clazz;
+    }
+
+  public DexClasspathClass ensureFixedClasspathClassFromType(
+      SyntheticKind kind,
+      DexType contextType,
+      AppView<?> appView,
+      Consumer<SyntheticClasspathClassBuilder> classConsumer,
+      Consumer<DexClasspathClass> onCreationConsumer) {
+    SynthesizingContext outerContext = SynthesizingContext.fromType(contextType);
+    DexType type = SyntheticNaming.createFixedType(kind, outerContext, appView.dexItemFactory());
+    return internalEnsureDexClasspathClass(
+        kind, classConsumer, onCreationConsumer, outerContext, type, appView);
+  }
+
+  public DexClassAndMethod ensureFixedClasspathClassFromTypeMethod(
+      DexString methodName,
+      DexProto methodProto,
+      SyntheticKind kind,
+      DexType contextType,
+      AppView<?> appView,
+      Consumer<SyntheticClasspathClassBuilder> classConsumer,
+      Consumer<DexClasspathClass> onCreationConsumer,
+      Consumer<SyntheticMethodBuilder> buildMethodCallback) {
+    DexClasspathClass clazz =
+        ensureFixedClasspathClassFromType(
+            kind, contextType, appView, classConsumer, onCreationConsumer);
+    DexMethod methodReference =
+        appView.dexItemFactory().createMethod(clazz.getType(), methodProto, methodName);
+    DexEncodedMethod methodDefinition =
+        internalEnsureMethod(
+            methodReference, clazz, kind, appView, buildMethodCallback, emptyConsumer());
+    return DexClassAndMethod.create(clazz, methodDefinition);
+  }
+
   public DexClassAndMethod ensureFixedClasspathClassMethod(
       DexString methodName,
       DexProto methodProto,
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
index 0e45bd8..567b595 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodBuilder.java
@@ -157,6 +157,10 @@
   }
 
   private Code getCodeObject(DexMethod methodSignature) {
+    if (codeGenerator == null) {
+      // The codeGenerator may be null on classpath classes.
+      return null;
+    }
     return codeGenerator.generate(methodSignature);
   }
 }
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
index 0a05c0f..872fdee 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
@@ -28,6 +28,7 @@
     ENUM_UNBOXING_LOCAL_UTILITY_CLASS("$EnumUnboxingLocalUtility", 24, false, true),
     ENUM_UNBOXING_SHARED_UTILITY_CLASS("$EnumUnboxingSharedUtility", 25, false, true),
     RECORD_TAG("", 1, false, true, true),
+    CUSTOM_CONVERSION("", 31, false, true),
     COMPANION_CLASS("$-CC", 2, false, true),
     EMULATED_INTERFACE_CLASS("$-EL", 3, false, true),
     RETARGET_CLASS("RetargetClass", 20, false, true),