diff --git a/build.gradle b/build.gradle
index a9574cc2..a024ae64 100644
--- a/build.gradle
+++ b/build.gradle
@@ -31,7 +31,6 @@ dependencies {
 
     compileOnlyApi 'com.google.code.findbugs:jsr305:3.0.2'
     implementation 'org.slf4j:slf4j-api:1.8.0-beta4'
-    implementation 'org.apache.commons:commons-lang3:3.12.0'
 
     testImplementation 'junit:junit-dep:4.10'
     testImplementation "org.slf4j:slf4j-simple:1.8.0-beta4"
diff --git a/src/main/java/com/mojang/datafixers/DSL.java b/src/main/java/com/mojang/datafixers/DSL.java
index a1580c1b..ae2c5892 100644
--- a/src/main/java/com/mojang/datafixers/DSL.java
+++ b/src/main/java/com/mojang/datafixers/DSL.java
@@ -2,7 +2,7 @@
 // Licensed under the MIT license.
 package com.mojang.datafixers;
 
-import com.google.common.collect.Maps;
+import com.google.common.collect.ObjectArrays;
 import com.mojang.datafixers.schemas.Schema;
 import com.mojang.datafixers.types.Func;
 import com.mojang.datafixers.types.Type;
@@ -22,13 +22,13 @@
 import com.mojang.datafixers.types.templates.TypeTemplate;
 import com.mojang.datafixers.util.Either;
 import com.mojang.datafixers.util.Pair;
+import com.mojang.datafixers.util.Triple;
 import com.mojang.datafixers.util.Unit;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.Dynamic;
-import org.apache.commons.lang3.ArrayUtils;
-import org.apache.commons.lang3.tuple.Triple;
 
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
@@ -155,7 +155,7 @@ static TypeTemplate and(final TypeTemplate first, final TypeTemplate... rest) {
     }
 
     static TypeTemplate allWithRemainder(final TypeTemplate first, final TypeTemplate... rest) {
-        return and(first, ArrayUtils.add(rest, remainder()));
+        return and(first, ObjectArrays.concat(rest, remainder()));
     }
 
     static <F, G> Type<Pair<F, G>> and(final Type<F> first, final Type<G> second) {
@@ -200,7 +200,7 @@ static <K> TaggedChoice<K> taggedChoiceLazy(final String name, final Type<K> key
 
     @SuppressWarnings("unchecked")
     static <K> Type<Pair<K, ?>> taggedChoiceType(final String name, final Type<K> keyType, final Map<K, ? extends Type<?>> types) {
-        return (Type<Pair<K, ?>>) Instances.TAGGED_CHOICE_TYPE_CACHE.computeIfAbsent(Triple.of(name, keyType, types), k -> new TaggedChoice.TaggedChoiceType<>(k.getLeft(), (Type<K>) k.getMiddle(), (Map<K, Type<?>>) k.getRight()));
+        return (Type<Pair<K, ?>>) Instances.TAGGED_CHOICE_TYPE_CACHE.computeIfAbsent(Triple.of(name, keyType, types), k -> new TaggedChoice.TaggedChoiceType<>(k.getFirst(), (Type<K>) k.getSecond(), (Map<K, Type<?>>) k.getThird()));
     }
 
     static <A, B> Type<Function<A, B>> func(final Type<A> input, final Type<B> output) {
@@ -447,6 +447,6 @@ final class Instances {
 
         private static final OpticFinder<Dynamic<?>> REMAINDER_FINDER = remainderType().finder();
 
-        private static final Map<Triple<String, Type<?>, Map<?, ? extends Type<?>>>, Type<? extends Pair<?, ?>>> TAGGED_CHOICE_TYPE_CACHE = Maps.newConcurrentMap();
+        private static final Map<Triple<String, Type<?>, Map<?, ? extends Type<?>>>, Type<? extends Pair<?, ?>>> TAGGED_CHOICE_TYPE_CACHE = new ConcurrentHashMap<>();
     }
 }
diff --git a/src/main/java/com/mojang/datafixers/DataFixerBuilder.java b/src/main/java/com/mojang/datafixers/DataFixerBuilder.java
index d25f106a..63a2d3ba 100644
--- a/src/main/java/com/mojang/datafixers/DataFixerBuilder.java
+++ b/src/main/java/com/mojang/datafixers/DataFixerBuilder.java
@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 package com.mojang.datafixers;
 
-import com.google.common.collect.Lists;
 import com.mojang.datafixers.schemas.Schema;
 import com.mojang.datafixers.types.Type;
 import it.unimi.dsi.fastutil.ints.Int2ObjectAVLTreeMap;
@@ -26,7 +25,7 @@ public class DataFixerBuilder {
 
     private final int dataVersion;
     private final Int2ObjectSortedMap<Schema> schemas = new Int2ObjectAVLTreeMap<>();
-    private final List<DataFix> globalList = Lists.newArrayList();
+    private final List<DataFix> globalList = new ArrayList<>();
     private final IntSortedSet fixerVersions = new IntAVLTreeSet();
 
     public DataFixerBuilder(final int dataVersion) {
@@ -69,7 +68,7 @@ public DataFixer buildOptimized(final Executor executor) {
         final DataFixerUpper fixerUpper = build();
 
         final Instant started = Instant.now();
-        final List<CompletableFuture<Void>> futures = Lists.newArrayList();
+        final List<CompletableFuture<Void>> futures = new ArrayList<>();
 
         final IntBidirectionalIterator iterator = fixerUpper.fixerVersions().iterator();
         while (iterator.hasNext()) {
diff --git a/src/main/java/com/mojang/datafixers/DataFixerUpper.java b/src/main/java/com/mojang/datafixers/DataFixerUpper.java
index f39325d7..b0309495 100644
--- a/src/main/java/com/mojang/datafixers/DataFixerUpper.java
+++ b/src/main/java/com/mojang/datafixers/DataFixerUpper.java
@@ -3,7 +3,6 @@
 package com.mojang.datafixers;
 
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
 import com.mojang.datafixers.functions.PointFreeRule;
 import com.mojang.datafixers.schemas.Schema;
 import com.mojang.datafixers.types.Type;
@@ -17,6 +16,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /*
@@ -123,7 +123,7 @@ protected TypeRewriteRule getRule(final int version, final int dataVersion) {
 
         final long key = (long) expandedVersion << 32 | expandedDataVersion;
         return rules.computeIfAbsent(key, k -> {
-            final List<TypeRewriteRule> rules = Lists.newArrayList();
+            final List<TypeRewriteRule> rules = new ArrayList<>();
             for (final DataFix fix : globalList) {
                 final int fixVersion = fix.getVersionKey();
                 if (fixVersion > expandedVersion && fixVersion <= expandedDataVersion) {
diff --git a/src/main/java/com/mojang/datafixers/RewriteResult.java b/src/main/java/com/mojang/datafixers/RewriteResult.java
index e85c71f8..48044876 100644
--- a/src/main/java/com/mojang/datafixers/RewriteResult.java
+++ b/src/main/java/com/mojang/datafixers/RewriteResult.java
@@ -4,7 +4,6 @@
 
 import com.mojang.datafixers.types.Type;
 import com.mojang.datafixers.types.templates.RecursivePoint;
-import org.apache.commons.lang3.ObjectUtils;
 
 import java.util.BitSet;
 import java.util.Objects;
@@ -30,7 +29,7 @@ public <C> RewriteResult<C, B> compose(final RewriteResult<C, A> that) {
         final BitSet newData;
         if (view.type() instanceof RecursivePoint.RecursivePointType<?> && that.view.type() instanceof RecursivePoint.RecursivePointType<?>) {
             // same family, merge results - not exactly accurate, but should be good enough
-            newData = ObjectUtils.clone(recData);
+            newData = (BitSet) recData.clone();
             newData.or(that.recData);
         } else {
             newData = recData;
diff --git a/src/main/java/com/mojang/datafixers/TypedOptic.java b/src/main/java/com/mojang/datafixers/TypedOptic.java
index 10c55657..ae8f2383 100644
--- a/src/main/java/com/mojang/datafixers/TypedOptic.java
+++ b/src/main/java/com/mojang/datafixers/TypedOptic.java
@@ -3,7 +3,6 @@
 package com.mojang.datafixers;
 
 import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Maps;
 import com.google.common.reflect.TypeToken;
 import com.mojang.datafixers.kinds.App;
 import com.mojang.datafixers.kinds.App2;
@@ -27,6 +26,7 @@
 import com.mojang.datafixers.util.Pair;
 
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -205,7 +205,7 @@ public static <A, B> TypedOptic<List<A>, List<B>, A, B> list(final Type<A> aType
         if (!Objects.equals(sType.types().get(key), aType)) {
             throw new IllegalArgumentException("Focused type doesn't match.");
         }
-        final Map<K, Type<?>> newTypes = Maps.newHashMap(sType.types());
+        final Map<K, Type<?>> newTypes = new HashMap<>(sType.types());
         newTypes.put(key, bType);
         final Type<Pair<K, ?>> pairType = DSL.taggedChoiceType(sType.getName(), sType.getKeyType(), newTypes);
         return new TypedOptic<>(
diff --git a/src/main/java/com/mojang/datafixers/functions/Fold.java b/src/main/java/com/mojang/datafixers/functions/Fold.java
index 54f1afd4..82514a9b 100644
--- a/src/main/java/com/mojang/datafixers/functions/Fold.java
+++ b/src/main/java/com/mojang/datafixers/functions/Fold.java
@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 package com.mojang.datafixers.functions;
 
-import com.google.common.collect.Maps;
 import com.mojang.datafixers.RewriteResult;
 import com.mojang.datafixers.View;
 import com.mojang.datafixers.types.families.Algebra;
@@ -13,12 +12,13 @@
 
 import java.util.Map;
 import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 import java.util.function.IntFunction;
 
 final class Fold<A, B> extends PointFree<Function<A, B>> {
-    private static final Map<Pair<RecursiveTypeFamily, Algebra>, IntFunction<RewriteResult<?, ?>>> HMAP_CACHE = Maps.newConcurrentMap();
-    private static final Map<Pair<IntFunction<RewriteResult<?, ?>>, Integer>, RewriteResult<?, ?>> HMAP_APPLY_CACHE = Maps.newConcurrentMap();
+    private static final Map<Pair<RecursiveTypeFamily, Algebra>, IntFunction<RewriteResult<?, ?>>> HMAP_CACHE = new ConcurrentHashMap<>();
+    private static final Map<Pair<IntFunction<RewriteResult<?, ?>>, Integer>, RewriteResult<?, ?>> HMAP_APPLY_CACHE = new ConcurrentHashMap<>();
 
     protected final RecursivePoint.RecursivePointType<A> aType;
     protected final RewriteResult<?, B> function;
diff --git a/src/main/java/com/mojang/datafixers/functions/PointFree.java b/src/main/java/com/mojang/datafixers/functions/PointFree.java
index f7593e3b..fb8ca6ae 100644
--- a/src/main/java/com/mojang/datafixers/functions/PointFree.java
+++ b/src/main/java/com/mojang/datafixers/functions/PointFree.java
@@ -2,9 +2,9 @@
 // Licensed under the MIT license.
 package com.mojang.datafixers.functions;
 
+import com.google.common.base.Strings;
 import com.mojang.datafixers.types.Type;
 import com.mojang.serialization.DynamicOps;
-import org.apache.commons.lang3.StringUtils;
 
 import javax.annotation.Nullable;
 import java.util.Optional;
@@ -44,7 +44,7 @@ public final String toString() {
     }
 
     public static String indent(final int level) {
-        return StringUtils.repeat("  ", level);
+        return Strings.repeat("  ", level);
     }
 
     public abstract String toString(int level);
diff --git a/src/main/java/com/mojang/datafixers/functions/PointFreeRule.java b/src/main/java/com/mojang/datafixers/functions/PointFreeRule.java
index eaee52d2..7ea8b735 100644
--- a/src/main/java/com/mojang/datafixers/functions/PointFreeRule.java
+++ b/src/main/java/com/mojang/datafixers/functions/PointFreeRule.java
@@ -3,7 +3,6 @@
 package com.mojang.datafixers.functions;
 
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
 import com.mojang.datafixers.DSL;
 import com.mojang.datafixers.DataFixUtils;
 import com.mojang.datafixers.RewriteResult;
@@ -20,8 +19,8 @@
 import com.mojang.datafixers.types.families.RecursiveTypeFamily;
 import com.mojang.datafixers.util.Either;
 import com.mojang.datafixers.util.Pair;
-import org.apache.commons.lang3.ObjectUtils;
 
+import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.List;
 import java.util.Objects;
@@ -392,7 +391,7 @@ public <A> Optional<? extends PointFree<?>> doRewrite(final Type<A> type, final
                 final RecursiveTypeFamily family = firstFold.aType.family();
                 if (Objects.equals(family, secondFold.aType.family()) && firstFold.index == secondFold.index) {
                     // same fold
-                    final List<RewriteResult<?, ?>> newAlgebra = Lists.newArrayList();
+                    final List<RewriteResult<?, ?>> newAlgebra = new ArrayList<>();
 
                     // merge where both are touching, id where neither is
 
@@ -439,7 +438,7 @@ public <A> Optional<? extends PointFree<?>> doRewrite(final Type<A> type, final
                 final RecursiveTypeFamily family = firstFold.aType.family();
                 if (Objects.equals(family, secondFold.aType.family()) && firstFold.index == secondFold.index) {
                     // same fold
-                    final List<RewriteResult<?, ?>> newAlgebra = Lists.newArrayList();
+                    final List<RewriteResult<?, ?>> newAlgebra = new ArrayList<>();
 
                     final BitSet firstModifies = new BitSet(family.size());
                     final BitSet secondModifies = new BitSet(family.size());
@@ -453,7 +452,7 @@ public <A> Optional<? extends PointFree<?>> doRewrite(final Type<A> type, final
                         secondModifies.set(i, !secondId);
                     }
 
-                    final BitSet newSet = ObjectUtils.clone(firstModifies);
+                    final BitSet newSet = (BitSet) firstModifies.clone();
                     newSet.or(secondModifies);
 
                     // if the left function doesn't care about the right modifications, and converse is correct, the merge is valid
diff --git a/src/main/java/com/mojang/datafixers/schemas/Schema.java b/src/main/java/com/mojang/datafixers/schemas/Schema.java
index 6ad85fda..6486ac07 100644
--- a/src/main/java/com/mojang/datafixers/schemas/Schema.java
+++ b/src/main/java/com/mojang/datafixers/schemas/Schema.java
@@ -2,8 +2,6 @@
 // Licensed under the MIT license.
 package com.mojang.datafixers.schemas;
 
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
 import com.mojang.datafixers.DSL;
 import com.mojang.datafixers.DataFixUtils;
 import com.mojang.datafixers.types.Type;
@@ -15,6 +13,8 @@
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -23,7 +23,7 @@
 
 public class Schema {
     protected final Object2IntMap<String> RECURSIVE_TYPES = new Object2IntOpenHashMap<>();
-    private final Map<String, Supplier<TypeTemplate>> TYPE_TEMPLATES = Maps.newHashMap();
+    private final Map<String, Supplier<TypeTemplate>> TYPE_TEMPLATES = new HashMap<>();
     private final Map<String, Type<?>> TYPES;
     private final int versionKey;
     private final String name;
@@ -39,9 +39,9 @@ public Schema(final int versionKey, final Schema parent) {
     }
 
     protected Map<String, Type<?>> buildTypes() {
-        final Map<String, Type<?>> types = Maps.newHashMap();
+        final Map<String, Type<?>> types = new HashMap<>();
 
-        final List<TypeTemplate> templates = Lists.newArrayList();
+        final List<TypeTemplate> templates = new ArrayList<>();
 
         for (final Object2IntMap.Entry<String> entry : RECURSIVE_TYPES.object2IntEntrySet()) {
             templates.add(DSL.check(entry.getKey(), entry.getIntValue(), getTemplate(entry.getKey())));
diff --git a/src/main/java/com/mojang/datafixers/types/Type.java b/src/main/java/com/mojang/datafixers/types/Type.java
index 4592da3c..afa37729 100644
--- a/src/main/java/com/mojang/datafixers/types/Type.java
+++ b/src/main/java/com/mojang/datafixers/types/Type.java
@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 package com.mojang.datafixers.types;
 
-import com.google.common.collect.Maps;
 import com.mojang.datafixers.DSL;
 import com.mojang.datafixers.DataFixUtils;
 import com.mojang.datafixers.FieldFinder;
@@ -22,22 +21,23 @@
 import com.mojang.datafixers.types.templates.TypeTemplate;
 import com.mojang.datafixers.util.Either;
 import com.mojang.datafixers.util.Pair;
+import com.mojang.datafixers.util.Triple;
+import com.mojang.datafixers.util.ValueHolder;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.DataResult;
 import com.mojang.serialization.Dynamic;
 import com.mojang.serialization.DynamicOps;
-import org.apache.commons.lang3.mutable.MutableObject;
-import org.apache.commons.lang3.tuple.Triple;
 
 import javax.annotation.Nullable;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CompletableFuture;
 
 public abstract class Type<A> implements App<Type.Mu, A> {
-    private static final Map<Triple<Type<?>, TypeRewriteRule, PointFreeRule>, CompletableFuture<Optional<? extends RewriteResult<?, ?>>>> PENDING_REWRITE_CACHE = Maps.newConcurrentMap();
-    private static final Map<Triple<Type<?>, TypeRewriteRule, PointFreeRule>, Optional<? extends RewriteResult<?, ?>>> REWRITE_CACHE = Maps.newConcurrentMap();
+    private static final Map<Triple<Type<?>, TypeRewriteRule, PointFreeRule>, CompletableFuture<Optional<? extends RewriteResult<?, ?>>>> PENDING_REWRITE_CACHE = new ConcurrentHashMap<>();
+    private static final Map<Triple<Type<?>, TypeRewriteRule, PointFreeRule>, Optional<? extends RewriteResult<?, ?>>> REWRITE_CACHE = new ConcurrentHashMap<>();
 
     public static class Mu implements K1 {}
 
@@ -178,7 +178,7 @@ private <T, B> DataResult<T> capWrite(final DynamicOps<T> ops, final Type<?> exp
             return (Optional<RewriteResult<A, ?>>) rewrite;
         }
         // TODO: AtomicReference.getPlain/setPlain in java9+
-        final MutableObject<CompletableFuture<Optional<? extends RewriteResult<?, ?>>>> ref = new MutableObject<>();
+        final ValueHolder<CompletableFuture<Optional<? extends RewriteResult<?, ?>>>> ref = new ValueHolder<>(null);
 
         final CompletableFuture<Optional<? extends RewriteResult<?, ?>>> pending = PENDING_REWRITE_CACHE.computeIfAbsent(key, k -> {
             final CompletableFuture<Optional<? extends RewriteResult<?, ?>>> value = new CompletableFuture<>();
diff --git a/src/main/java/com/mojang/datafixers/types/families/RecursiveTypeFamily.java b/src/main/java/com/mojang/datafixers/types/families/RecursiveTypeFamily.java
index fcbb52f7..1c5e3de7 100644
--- a/src/main/java/com/mojang/datafixers/types/families/RecursiveTypeFamily.java
+++ b/src/main/java/com/mojang/datafixers/types/families/RecursiveTypeFamily.java
@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 package com.mojang.datafixers.types.families;
 
-import com.google.common.collect.Lists;
 import com.mojang.datafixers.DataFixUtils;
 import com.mojang.datafixers.FamilyOptic;
 import com.mojang.datafixers.OpticParts;
@@ -23,6 +22,7 @@
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 
 import javax.annotation.Nullable;
+import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.List;
 import java.util.Objects;
@@ -112,7 +112,7 @@ public RecursivePoint.RecursivePointType<?> apply(final int index) {
     public <A, B> Either<TypedOptic<?, ?, A, B>, Type.FieldNotFoundException> findType(final int index, final Type<A> aType, final Type<B> bType, final Type.TypeMatcher<A, B> matcher, final boolean recurse) {
         return apply(index).unfold().findType(aType, bType, matcher, false).flatMap(optic -> {
             final TypeTemplate nc = optic.tType().template();
-            final List<FamilyOptic<A, B>> fo = Lists.newArrayList();
+            final List<FamilyOptic<A, B>> fo = new ArrayList<>();
             final RecursiveTypeFamily newFamily = new RecursiveTypeFamily(name, nc);
 
             final RecursivePoint.RecursivePointType<?> sType = apply(index);
@@ -152,7 +152,7 @@ private <S, T, A, B> TypedOptic<S, T, A, B> mkOptic(final Type<S> sType, final T
         final RecursivePoint.RecursivePointType<?> newType = buildMuType(sourceView.view().newType(), null);
         final RecursiveTypeFamily newFamily = newType.family();
 
-        final List<RewriteResult<?, ?>> views = Lists.newArrayList();
+        final List<RewriteResult<?, ?>> views = new ArrayList<>();
         boolean foundAny = false;
         // FB -> B
         for (int i = 0; i < size; i++) {
diff --git a/src/main/java/com/mojang/datafixers/types/templates/CompoundList.java b/src/main/java/com/mojang/datafixers/types/templates/CompoundList.java
index a67d421d..79f8c88f 100644
--- a/src/main/java/com/mojang/datafixers/types/templates/CompoundList.java
+++ b/src/main/java/com/mojang/datafixers/types/templates/CompoundList.java
@@ -3,7 +3,6 @@
 package com.mojang.datafixers.types.templates;
 
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Sets;
 import com.google.common.reflect.TypeToken;
 import com.mojang.datafixers.DSL;
 import com.mojang.datafixers.DataFixUtils;
@@ -26,6 +25,7 @@
 import com.mojang.serialization.DynamicOps;
 
 import javax.annotation.Nullable;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -56,7 +56,7 @@ public <A, B> FamilyOptic<A, B> applyO(final FamilyOptic<A, B> input, final Type
         return TypeFamily.familyOptic(
             i -> {
                 final OpticParts<A, B> optic = element.applyO(input, aType, bType).apply(i);
-                final Set<TypeToken<? extends K1>> bounds = Sets.newHashSet(optic.bounds());
+                final Set<TypeToken<? extends K1>> bounds = new HashSet<>(optic.bounds());
                 bounds.add(TraversalP.Mu.TYPE_TOKEN);
                 return new OpticParts<>(bounds, cap(optic.optic()));
             }
diff --git a/src/main/java/com/mojang/datafixers/types/templates/List.java b/src/main/java/com/mojang/datafixers/types/templates/List.java
index 984d852d..f9dad640 100644
--- a/src/main/java/com/mojang/datafixers/types/templates/List.java
+++ b/src/main/java/com/mojang/datafixers/types/templates/List.java
@@ -3,7 +3,6 @@
 package com.mojang.datafixers.types.templates;
 
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Sets;
 import com.google.common.reflect.TypeToken;
 import com.mojang.datafixers.DSL;
 import com.mojang.datafixers.FamilyOptic;
@@ -23,6 +22,7 @@
 import com.mojang.serialization.DynamicOps;
 
 import javax.annotation.Nullable;
+import java.util.HashSet;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
@@ -65,7 +65,7 @@ public <A, B> FamilyOptic<A, B> applyO(final FamilyOptic<A, B> input, final Type
         return TypeFamily.familyOptic(
             i -> {
                 final OpticParts<A, B> pair = element.applyO(input, aType, bType).apply(i);
-                final Set<TypeToken<? extends K1>> bounds = Sets.newHashSet(pair.bounds());
+                final Set<TypeToken<? extends K1>> bounds = new HashSet<>(pair.bounds());
                 bounds.add(TraversalP.Mu.TYPE_TOKEN);
                 return new OpticParts<>(bounds, cap(pair.optic()));
             }
diff --git a/src/main/java/com/mojang/datafixers/types/templates/RecursivePoint.java b/src/main/java/com/mojang/datafixers/types/templates/RecursivePoint.java
index d20dd60c..8a4a6296 100644
--- a/src/main/java/com/mojang/datafixers/types/templates/RecursivePoint.java
+++ b/src/main/java/com/mojang/datafixers/types/templates/RecursivePoint.java
@@ -19,7 +19,6 @@
 import com.mojang.serialization.DataResult;
 import com.mojang.serialization.DynamicOps;
 import com.mojang.serialization.Lifecycle;
-import org.apache.commons.lang3.ObjectUtils;
 
 import javax.annotation.Nullable;
 import java.util.BitSet;
@@ -86,7 +85,7 @@ public <S, T> RewriteResult<S, T> cap(final TypeFamily family, final RewriteResu
         }
         final RecursivePointType<S> sType = (RecursivePointType<S>) sourceType;
         final RecursivePointType<T> tType = sType.family().buildMuType(result.view().newType(), null);
-        final BitSet bitSet = ObjectUtils.clone(result.recData());
+        final BitSet bitSet = (BitSet) result.recData().clone();
         bitSet.set(index);
         return RewriteResult.create(View.create(sType, tType, result.view().function()), bitSet);
     }
diff --git a/src/main/java/com/mojang/datafixers/types/templates/TaggedChoice.java b/src/main/java/com/mojang/datafixers/types/templates/TaggedChoice.java
index ef8fbd08..cb5dc1bd 100644
--- a/src/main/java/com/mojang/datafixers/types/templates/TaggedChoice.java
+++ b/src/main/java/com/mojang/datafixers/types/templates/TaggedChoice.java
@@ -3,8 +3,6 @@
 package com.mojang.datafixers.types.templates;
 
 import com.google.common.base.Joiner;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
 import com.google.common.reflect.TypeToken;
 import com.mojang.datafixers.DSL;
 import com.mojang.datafixers.FamilyOptic;
@@ -40,10 +38,13 @@
 import javax.annotation.Nullable;
 import java.util.Arrays;
 import java.util.BitSet;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 import java.util.function.IntFunction;
 
@@ -51,7 +52,7 @@ public final class TaggedChoice<K> implements TypeTemplate {
     private final String name;
     private final Type<K> keyType;
     private final Map<K, TypeTemplate> templates;
-    private final Map<Pair<TypeFamily, Integer>, Type<?>> types = Maps.newConcurrentMap();
+    private final Map<Pair<TypeFamily, Integer>, Type<?>> types = new ConcurrentHashMap<>();
     private final int size;
 
     public TaggedChoice(final String name, final Type<K> keyType, final Map<K, TypeTemplate> templates) {
@@ -145,7 +146,7 @@ public TaggedChoiceType(final String name, final Type<K> keyType, final Map<K, T
                 final Map.Entry<K, ? extends RewriteResult<?, ?>> entry = results.entrySet().iterator().next();
                 return elementResult(entry.getKey(), this, entry.getValue());
             }
-            final Map<K, Type<?>> newTypes = Maps.newHashMap(types);
+            final Map<K, Type<?>> newTypes = new HashMap<>(types);
             final BitSet recData = new BitSet();
             for (final Map.Entry<K, ? extends RewriteResult<?, ?>> entry : results.entrySet()) {
                 newTypes.put(entry.getKey(), entry.getValue().view().newType());
@@ -231,7 +232,7 @@ public Optional<Type<?>> findFieldTypeOpt(final String name) {
                 final Map.Entry<K, ? extends TypedOptic<?, ?, FT, FR>> entry = optics.entrySet().iterator().next();
                 return Either.left(cap(this, entry.getKey(), entry.getValue()));
             } else {
-                final Set<TypeToken<? extends K1>> bounds = Sets.newHashSet();
+                final Set<TypeToken<? extends K1>> bounds = new HashSet<>();
                 optics.values().forEach(o -> bounds.addAll(o.bounds()));
 
                 final Optic<?, Pair<K, ?>, Pair<K, ?>, FT, FR> optic;
diff --git a/src/main/java/com/mojang/datafixers/util/Pair.java b/src/main/java/com/mojang/datafixers/util/Pair.java
index dfa0280e..73a1f481 100644
--- a/src/main/java/com/mojang/datafixers/util/Pair.java
+++ b/src/main/java/com/mojang/datafixers/util/Pair.java
@@ -57,7 +57,7 @@ public boolean equals(final Object obj) {
 
     @Override
     public int hashCode() {
-        return com.google.common.base.Objects.hashCode(first, second);
+        return Objects.hash(first, second);
     }
 
     public <F2> Pair<F2, S> mapFirst(final Function<? super F, ? extends F2> function) {
diff --git a/src/main/java/com/mojang/datafixers/util/Triple.java b/src/main/java/com/mojang/datafixers/util/Triple.java
new file mode 100644
index 00000000..a66a69b0
--- /dev/null
+++ b/src/main/java/com/mojang/datafixers/util/Triple.java
@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+package com.mojang.datafixers.util;
+
+import java.util.Objects;
+
+public class Triple<F, S, T> {
+    private final F first;
+    private final S second;
+    private final T third;
+
+    public Triple(final F first, final S second, final T third) {
+        this.first = first;
+        this.second = second;
+        this.third = third;
+    }
+
+    public F getFirst() {
+        return first;
+    }
+
+    public S getSecond() {
+        return second;
+    }
+
+    public T getThird() {
+        return third;
+    }
+
+    @Override
+    public String toString() {
+        return "(" + first + ", " + second + ", " + third + ")";
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Triple)) {
+            return false;
+        }
+
+        final Triple<?, ?, ?> other = (Triple<?, ?, ?>) obj;
+        return Objects.equals(first, other.first) && Objects.equals(second, other.second) && Objects.equals(third, other.third);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(first, second, third);
+    }
+
+    public static <F, S, T> Triple<F, S, T> of(final F first, final S second, T third) {
+        return new Triple<>(first, second, third);
+    }
+}
diff --git a/src/main/java/com/mojang/datafixers/util/ValueHolder.java b/src/main/java/com/mojang/datafixers/util/ValueHolder.java
new file mode 100644
index 00000000..2981920d
--- /dev/null
+++ b/src/main/java/com/mojang/datafixers/util/ValueHolder.java
@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+package com.mojang.datafixers.util;
+
+import java.util.Objects;
+
+public class ValueHolder<T> {
+    private T value;
+
+    public ValueHolder(final T value) {
+        this.value = value;
+    }
+
+    public T getValue() {
+        return value;
+    }
+
+    public ValueHolder<T> setValue(final T value) {
+        this.value = value;
+        return this;
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof ValueHolder)) {
+            return false;
+        }
+
+        ValueHolder<?> other = (ValueHolder<?>) obj;
+        return Objects.equals(value, other.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return value != null ? value.hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(value);
+    }
+}
diff --git a/src/main/java/com/mojang/serialization/DynamicLike.java b/src/main/java/com/mojang/serialization/DynamicLike.java
index 1ef30b43..75eee188 100644
--- a/src/main/java/com/mojang/serialization/DynamicLike.java
+++ b/src/main/java/com/mojang/serialization/DynamicLike.java
@@ -8,7 +8,7 @@
 import com.mojang.datafixers.kinds.ListBox;
 import com.mojang.datafixers.util.Function3;
 import com.mojang.datafixers.util.Pair;
-import org.apache.commons.lang3.mutable.MutableObject;
+import com.mojang.datafixers.util.ValueHolder;
 
 import java.nio.ByteBuffer;
 import java.util.List;
@@ -90,7 +90,7 @@ public <K, V> DataResult<List<Pair<K, V>>> readMap(final Decoder<K> keyDecoder,
     public <R> DataResult<R> readMap(final DataResult<R> empty, final Function3<R, Dynamic<T>, Dynamic<T>, DataResult<R>> combiner) {
         return asMapOpt().flatMap(stream -> {
             // TODO: AtomicReference.getPlain/setPlain in java9+
-            final MutableObject<DataResult<R>> result = new MutableObject<>(empty);
+            final ValueHolder<DataResult<R>> result = new ValueHolder<>(empty);
             stream.forEach(p -> result.setValue(result.getValue().flatMap(r -> combiner.apply(r, p.getFirst(), p.getSecond()))));
             return result.getValue();
         });
diff --git a/src/main/java/com/mojang/serialization/DynamicOps.java b/src/main/java/com/mojang/serialization/DynamicOps.java
index 4d65714b..b5d252db 100644
--- a/src/main/java/com/mojang/serialization/DynamicOps.java
+++ b/src/main/java/com/mojang/serialization/DynamicOps.java
@@ -4,7 +4,7 @@
 
 import com.google.common.collect.ImmutableMap;
 import com.mojang.datafixers.util.Pair;
-import org.apache.commons.lang3.mutable.MutableObject;
+import com.mojang.datafixers.util.ValueHolder;
 
 import java.nio.ByteBuffer;
 import java.util.List;
@@ -101,7 +101,7 @@ default DataResult<T> mergeToMap(final T map, final Map<T, T> values) {
 
     default DataResult<T> mergeToMap(final T map, final MapLike<T> values) {
         // TODO: AtomicReference.getPlain/setPlain in java9+
-        final MutableObject<DataResult<T>> result = new MutableObject<>(DataResult.success(map));
+        final ValueHolder<DataResult<T>> result = new ValueHolder<>(DataResult.success(map));
 
         values.entries().forEach(entry ->
             result.setValue(result.getValue().flatMap(r -> mergeToMap(r, entry.getFirst(), entry.getSecond())))
diff --git a/src/main/java/com/mojang/serialization/JsonOps.java b/src/main/java/com/mojang/serialization/JsonOps.java
index d4f42a41..044739d9 100644
--- a/src/main/java/com/mojang/serialization/JsonOps.java
+++ b/src/main/java/com/mojang/serialization/JsonOps.java
@@ -2,7 +2,6 @@
 // Licensed under the MIT license.
 package com.mojang.serialization;
 
-import com.google.common.collect.Lists;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonNull;
@@ -12,6 +11,7 @@
 
 import javax.annotation.Nullable;
 import java.math.BigDecimal;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -192,7 +192,7 @@ public DataResult<JsonElement> mergeToMap(final JsonElement map, final MapLike<J
             map.getAsJsonObject().entrySet().forEach(entry -> output.add(entry.getKey(), entry.getValue()));
         }
 
-        final List<JsonElement> missed = Lists.newArrayList();
+        final List<JsonElement> missed = new ArrayList<>();
 
         values.entries().forEach(entry -> {
             final JsonElement key = entry.getFirst();
diff --git a/src/main/java/com/mojang/serialization/codecs/CompoundListCodec.java b/src/main/java/com/mojang/serialization/codecs/CompoundListCodec.java
index 883c61ac..b337a80a 100644
--- a/src/main/java/com/mojang/serialization/codecs/CompoundListCodec.java
+++ b/src/main/java/com/mojang/serialization/codecs/CompoundListCodec.java
@@ -6,12 +6,12 @@
 import com.google.common.collect.ImmutableMap;
 import com.mojang.datafixers.util.Pair;
 import com.mojang.datafixers.util.Unit;
+import com.mojang.datafixers.util.ValueHolder;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.DataResult;
 import com.mojang.serialization.DynamicOps;
 import com.mojang.serialization.Lifecycle;
 import com.mojang.serialization.RecordBuilder;
-import org.apache.commons.lang3.mutable.MutableObject;
 
 import java.util.List;
 import java.util.Objects;
@@ -32,7 +32,7 @@ public <T> DataResult<Pair<List<Pair<K, V>>, T>> decode(final DynamicOps<T> ops,
             final ImmutableMap.Builder<T, T> failed = ImmutableMap.builder();
 
             // TODO: AtomicReference.getPlain/setPlain in java9+
-            final MutableObject<DataResult<Unit>> result = new MutableObject<>(DataResult.success(Unit.INSTANCE, Lifecycle.experimental()));
+            final ValueHolder<DataResult<Unit>> result = new ValueHolder<>(DataResult.success(Unit.INSTANCE, Lifecycle.experimental()));
 
             map.accept((key, value) -> {
                 final DataResult<K> k = keyCodec.parse(ops, key);
diff --git a/src/main/java/com/mojang/serialization/codecs/ListCodec.java b/src/main/java/com/mojang/serialization/codecs/ListCodec.java
index 85152819..73eaf686 100644
--- a/src/main/java/com/mojang/serialization/codecs/ListCodec.java
+++ b/src/main/java/com/mojang/serialization/codecs/ListCodec.java
@@ -5,12 +5,12 @@
 import com.google.common.collect.ImmutableList;
 import com.mojang.datafixers.util.Pair;
 import com.mojang.datafixers.util.Unit;
+import com.mojang.datafixers.util.ValueHolder;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.DataResult;
 import com.mojang.serialization.DynamicOps;
 import com.mojang.serialization.Lifecycle;
 import com.mojang.serialization.ListBuilder;
-import org.apache.commons.lang3.mutable.MutableObject;
 
 import java.util.List;
 import java.util.Objects;
@@ -40,7 +40,7 @@ public <T> DataResult<Pair<List<A>, T>> decode(final DynamicOps<T> ops, final T
             final ImmutableList.Builder<A> read = ImmutableList.builder();
             final Stream.Builder<T> failed = Stream.builder();
             // TODO: AtomicReference.getPlain/setPlain in java9+
-            final MutableObject<DataResult<Unit>> result = new MutableObject<>(DataResult.success(Unit.INSTANCE, Lifecycle.stable()));
+            final ValueHolder<DataResult<Unit>> result = new ValueHolder<>(DataResult.success(Unit.INSTANCE, Lifecycle.stable()));
 
             stream.accept(t -> {
                 final DataResult<Pair<A, T>> element = elementCodec.decode(ops, t);