diff --git a/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/CompoundTagImpl.java b/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/CompoundTagImpl.java
new file mode 100644
index 0000000..b9cf5fb
--- /dev/null
+++ b/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/CompoundTagImpl.java
@@ -0,0 +1,310 @@
+package de.cubeside.nmsutils.v1_20_R1;
+
+import com.google.common.base.Preconditions;
+import de.cubeside.nmsutils.nbt.TagType;
+import java.util.Collections;
+import java.util.Set;
+import java.util.UUID;
+import net.minecraft.nbt.ByteArrayTag;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.IntArrayTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.nbt.LongArrayTag;
+import net.minecraft.nbt.NumericTag;
+import net.minecraft.nbt.StringTag;
+import net.minecraft.nbt.Tag;
+
+public final class CompoundTagImpl implements de.cubeside.nmsutils.nbt.CompoundTag {
+    final CompoundTag handle;
+
+    public CompoundTagImpl(CompoundTag handle) {
+        this.handle = handle;
+    }
+
+    @Override
+    public boolean containsKey(String key) {
+        return handle.contains(key);
+    }
+
+    @Override
+    public boolean containsKey(String key, TagType type) {
+        if (type == TagType.UUID) {
+            return handle.hasUUID(key);
+        }
+        return handle.contains(key, type.internalId());
+    }
+
+    @Override
+    public void clear() {
+        handle.getAllKeys().clear();
+    }
+
+    @Override
+    public void remove(String string) {
+        handle.remove(string);
+    }
+
+    @Override
+    public Set<String> getAllKeys() {
+        return Collections.unmodifiableSet(handle.getAllKeys());
+    }
+
+    @Override
+    public void size() {
+        handle.size();
+    }
+
+    @Override
+    public CompoundTagImpl getCompound(String name) {
+        return getCompound(name, false);
+    }
+
+    @Override
+    public CompoundTagImpl getCompound(String name, boolean createIfMissing) {
+        Preconditions.checkNotNull(name);
+        Tag tag = handle.get(name);
+        if (!(tag instanceof CompoundTag)) {
+            if (!createIfMissing) {
+                return null;
+            }
+            tag = new CompoundTag();
+            handle.put(name, tag);
+        }
+        return new CompoundTagImpl((CompoundTag) tag);
+    }
+
+    @Override
+    public ListTagImpl getList(String name) {
+        return getList(name, false);
+    }
+
+    @Override
+    public ListTagImpl getList(String name, boolean createIfMissing) {
+        Preconditions.checkNotNull(name);
+        Tag tag = handle.get(name);
+        if (!(tag instanceof ListTag)) {
+            if (!createIfMissing) {
+                return null;
+            }
+            tag = new ListTag();
+            handle.put(name, tag);
+        }
+        return new ListTagImpl((ListTag) tag);
+    }
+
+    @Override
+    public byte getByte(String name) {
+        return getByte(name, (byte) 0);
+    }
+
+    @Override
+    public byte getByte(String name, byte defaultValue) {
+        if (handle.get(name) instanceof NumericTag tag) {
+            return tag.getAsByte();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setByte(String name, byte b) {
+        Preconditions.checkNotNull(name);
+        handle.putByte(name, b);
+    }
+
+    @Override
+    public short getShort(String name) {
+        return getShort(name, (short) 0);
+    }
+
+    @Override
+    public short getShort(String name, short defaultValue) {
+        if (handle.get(name) instanceof NumericTag tag) {
+            return tag.getAsShort();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setShort(String name, short s) {
+        Preconditions.checkNotNull(name);
+        handle.putShort(name, s);
+    }
+
+    @Override
+    public int getInt(String name) {
+        return getInt(name, 0);
+    }
+
+    @Override
+    public int getInt(String name, int defaultValue) {
+        if (handle.get(name) instanceof NumericTag tag) {
+            return tag.getAsInt();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setInt(String name, int v) {
+        Preconditions.checkNotNull(name);
+        handle.putInt(name, v);
+    }
+
+    @Override
+    public long getLong(String name) {
+        return getLong(name, 0L);
+    }
+
+    @Override
+    public long getLong(String name, long defaultValue) {
+        if (handle.get(name) instanceof NumericTag tag) {
+            return tag.getAsLong();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setLong(String name, long l) {
+        Preconditions.checkNotNull(name);
+        handle.putLong(name, l);
+    }
+
+    @Override
+    public float getFloat(String name) {
+        return getFloat(name, 0.0f);
+    }
+
+    @Override
+    public float getFloat(String name, float defaultValue) {
+        if (handle.get(name) instanceof NumericTag tag) {
+            return tag.getAsFloat();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setFloat(String name, float f) {
+        Preconditions.checkNotNull(name);
+        handle.putFloat(name, f);
+    }
+
+    @Override
+    public double getDouble(String name) {
+        return getDouble(name, 0.0);
+    }
+
+    @Override
+    public double getDouble(String name, double defaultValue) {
+        if (handle.get(name) instanceof NumericTag tag) {
+            return tag.getAsDouble();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setDouble(String name, double d) {
+        Preconditions.checkNotNull(name);
+        handle.putDouble(name, d);
+    }
+
+    @Override
+    public byte[] getByteArray(String name) {
+        return getByteArray(name, null);
+    }
+
+    @Override
+    public byte[] getByteArray(String name, byte[] defaultValue) {
+        if (handle.get(name) instanceof ByteArrayTag tag) {
+            return tag.getAsByteArray();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setByteArray(String name, byte[] b) {
+        Preconditions.checkNotNull(name);
+        Preconditions.checkNotNull(b);
+        handle.putByteArray(name, b);
+    }
+
+    @Override
+    public int[] getIntArray(String name) {
+        return getIntArray(name, null);
+    }
+
+    @Override
+    public int[] getIntArray(String name, int[] defaultValue) {
+        if (handle.get(name) instanceof IntArrayTag tag) {
+            return tag.getAsIntArray();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setIntArray(String name, int[] v) {
+        Preconditions.checkNotNull(name);
+        Preconditions.checkNotNull(v);
+        handle.putIntArray(name, v);
+    }
+
+    @Override
+    public long[] getLongArray(String name) {
+        return getLongArray(name, null);
+    }
+
+    @Override
+    public long[] getLongArray(String name, long[] defaultValue) {
+        if (handle.get(name) instanceof LongArrayTag tag) {
+            return tag.getAsLongArray();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setLongArray(String name, long[] v) {
+        Preconditions.checkNotNull(name);
+        Preconditions.checkNotNull(v);
+        handle.putLongArray(name, v);
+    }
+
+    @Override
+    public String getString(String name) {
+        return getString(name, null);
+    }
+
+    @Override
+    public String getString(String name, String defaultValue) {
+        if (handle.get(name) instanceof StringTag tag) {
+            return tag.getAsString();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public void setString(String name, String v) {
+        Preconditions.checkNotNull(name);
+        Preconditions.checkNotNull(v);
+        handle.putString(name, v);
+    }
+
+    @Override
+    public UUID getUUID(String name) {
+        return handle.hasUUID(name) ? handle.getUUID(name) : null;
+    }
+
+    @Override
+    public void setUUID(String name, UUID v) {
+        Preconditions.checkNotNull(name);
+        Preconditions.checkNotNull(v);
+        handle.putUUID(name, v);
+    }
+
+    @Override
+    public int hashCode() {
+        return handle.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof CompoundTagImpl o && handle.equals(o.handle);
+    }
+}
diff --git a/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/ListTagImpl.java b/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/ListTagImpl.java
new file mode 100644
index 0000000..948e985
--- /dev/null
+++ b/nmsutils-v1_20_R1/src/main/java/de/cubeside/nmsutils/v1_20_R1/ListTagImpl.java
@@ -0,0 +1,271 @@
+package de.cubeside.nmsutils.v1_20_R1;
+
+import de.cubeside.nmsutils.nbt.TagType;
+import net.minecraft.nbt.ByteTag;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.DoubleTag;
+import net.minecraft.nbt.FloatTag;
+import net.minecraft.nbt.IntTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.nbt.LongTag;
+import net.minecraft.nbt.NumericTag;
+import net.minecraft.nbt.ShortTag;
+
+public final class ListTagImpl implements de.cubeside.nmsutils.nbt.ListTag {
+    final ListTag handle;
+
+    public ListTagImpl(ListTag handle) {
+        this.handle = handle;
+    }
+
+    @Override
+    public int size() {
+        return handle.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return handle.isEmpty();
+    }
+
+    @Override
+    public TagType getElementType() {
+        return TagType.ofInternal(handle.getElementType());
+    }
+
+    @Override
+    public CompoundTagImpl getCompound(int index) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof CompoundTag t) {
+            return new CompoundTagImpl(t);
+        }
+        return null;
+    }
+
+    @Override
+    public CompoundTagImpl addCompound() {
+        return addCompound(size());
+    }
+
+    @Override
+    public CompoundTagImpl addCompound(int index) {
+        CompoundTag tag = new CompoundTag();
+        return handle.addTag(index, tag) ? new CompoundTagImpl(tag) : null;
+    }
+
+    @Override
+    public CompoundTagImpl setCompound(int index) {
+        CompoundTag tag = new CompoundTag();
+        return handle.setTag(index, tag) ? new CompoundTagImpl(tag) : null;
+    }
+
+    @Override
+    public ListTagImpl getList(int index) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof ListTag t) {
+            return new ListTagImpl(t);
+        }
+        return null;
+    }
+
+    @Override
+    public ListTagImpl addList() {
+        return addList(size());
+    }
+
+    @Override
+    public ListTagImpl addList(int index) {
+        ListTag tag = new ListTag();
+        return handle.addTag(index, tag) ? new ListTagImpl(tag) : null;
+    }
+
+    @Override
+    public ListTagImpl setList(int index) {
+        ListTag tag = new ListTag();
+        return handle.setTag(index, tag) ? new ListTagImpl(tag) : null;
+    }
+
+    @Override
+    public byte getByte(int index) {
+        return getByte(index, (byte) 0);
+    }
+
+    @Override
+    public byte getByte(int index, byte defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof NumericTag t) {
+            return t.getAsByte();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addByte(byte v) {
+        return addByte(size(), v);
+    }
+
+    @Override
+    public boolean addByte(int index, byte v) {
+        return handle.addTag(index, ByteTag.valueOf(v));
+    }
+
+    @Override
+    public boolean setByte(int index, byte v) {
+        return handle.setTag(index, ByteTag.valueOf(v));
+    }
+
+    @Override
+    public short getShort(int index) {
+        return getShort(index, (short) 0);
+    }
+
+    @Override
+    public short getShort(int index, short defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof NumericTag t) {
+            return t.getAsShort();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addShort(short v) {
+        return addShort(size(), v);
+    }
+
+    @Override
+    public boolean addShort(int index, short v) {
+        return handle.addTag(index, ShortTag.valueOf(v));
+    }
+
+    @Override
+    public boolean setShort(int index, short v) {
+        return handle.setTag(index, ShortTag.valueOf(v));
+    }
+
+    @Override
+    public int getInt(int index) {
+        return getInt(index, 0);
+    }
+
+    @Override
+    public int getInt(int index, int defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof NumericTag t) {
+            return t.getAsInt();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addInt(int v) {
+        return addInt(size(), v);
+    }
+
+    @Override
+    public boolean addInt(int index, int v) {
+        return handle.addTag(index, IntTag.valueOf(v));
+    }
+
+    @Override
+    public boolean setInt(int index, int v) {
+        return handle.setTag(index, IntTag.valueOf(v));
+    }
+
+    @Override
+    public long getLong(int index) {
+        return getLong(index, 0);
+    }
+
+    @Override
+    public long getLong(int index, long defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof NumericTag t) {
+            return t.getAsLong();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addLong(long v) {
+        return addLong(size(), v);
+    }
+
+    @Override
+    public boolean addLong(int index, long v) {
+        return handle.addTag(index, LongTag.valueOf(v));
+    }
+
+    @Override
+    public boolean setLong(int index, long v) {
+        return handle.setTag(index, LongTag.valueOf(v));
+    }
+
+    @Override
+    public float getFloat(int index) {
+        return getFloat(index, 0);
+    }
+
+    @Override
+    public float getFloat(int index, float defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof NumericTag t) {
+            return t.getAsFloat();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addFloat(float v) {
+        return addFloat(size(), v);
+    }
+
+    @Override
+    public boolean addFloat(int index, float v) {
+        return handle.addTag(index, FloatTag.valueOf(v));
+    }
+
+    @Override
+    public boolean setFloat(int index, float v) {
+        return handle.setTag(index, FloatTag.valueOf(v));
+    }
+
+    @Override
+    public double getDouble(int index) {
+        return getDouble(index, 0);
+    }
+
+    @Override
+    public double getDouble(int index, double defaultValue) {
+        if (index >= 0 && index < handle.size() && handle.get(index) instanceof NumericTag t) {
+            return t.getAsDouble();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public boolean addDouble(double v) {
+        return addDouble(size(), v);
+    }
+
+    @Override
+    public boolean addDouble(int index, double v) {
+        return handle.addTag(index, DoubleTag.valueOf(v));
+    }
+
+    @Override
+    public boolean setDouble(int index, double v) {
+        return handle.setTag(index, DoubleTag.valueOf(v));
+    }
+
+    public void remove(int i) {
+        handle.remove(i);
+    }
+
+    public void clear() {
+        handle.clear();
+    }
+
+    @Override
+    public int hashCode() {
+        return handle.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof ListTagImpl o && handle.equals(o.handle);
+    }
+}