diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,11 @@
 Major release 1.2
 -----------------
 
+## Version 1.2.0.1 (07-21-26)
+
+This upgrade applies the changes made by the XCodec v2.0 update, and upgrades
+all the modules effected.
+
 ## Version 1.2.0.0 (07-08-26)
 
 This version introduces the new XCodec changes and renames modules to match the
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -6,16 +6,19 @@
 ---------------------------------------------------------------
 
 This project implements the specifications described by Protocol Lab's
-[multiformats](https://github.com/multiformats/multiformats) written in Haskell.
+[multiformats](https://github.com/multiformats/multiformats) written in Haskell,
+and split across several directories described below.
 
-`cid` - Content identitiers for hashed data
+`cid` - Content identifiers for hashed data
 -------------------------------------------
 
-Provides functionality for the multiformats CID binary format. These modules
-provide parsing CIDs from multibase prefixed digit strings, extracting CID data
+Provides functionality for the multiformats [CID](
+https://github.com/multiformats/cid) binary format. These modules provide
+parsing CIDs from multibase prefixed digit strings, extracting CID data
 from byte strings and serializing CIDs stored in memory into its binary format.
 
-CID GitHub README example in GHCI:
+Multiformats CID GitHub [README example](
+https://github.com/multiformats/cid#variant---human-readable-form) in GHCI:
 ```haskell
 λ> {-# LANGUAGE OverloadedStrings #-}
 λ> import MultiFormats.CID (CID)
@@ -25,23 +28,17 @@
 Right CIDv1(DataCodec=MultiCodec(raw=0x55), HashCodec=MultiHash(sha2-256=0x12), HashDigest[32]=0x6e6ff7950a36187a801613426e858dce686cd7d7e3c0fc42ee0330072d245c95)
 ```
 
-- CID specification - [https://github.com/multiformats/cid](
-https://github.com/multiformats/cid)
-- CID example from README - [
-https://github.com/multiformats/cid#variant---human-readable-form](
-https://github.com/multiformats/cid#variant---human-readable-form)
-- Official IPFS Golang implementation - [https://github.com/ipfs/go-cid](
-https://github.com/ipfs/go-cid)
-
 `multibase` - Multibase prefix data transcoding
 -----------------------------------------------
 
-Implements encoders and decoders for numeric basesystems identified by a
-specified prefix symbol. It implements transcoders from the [basesystems](
-https://git.sr.ht/~z0/basesystems) library, allowing for different types of
-bytestring data to be specified as type parameters.
+Implements [multibase](https://github.com/multiformats/multibase) encoders and
+decoders for numeric basesystems identified by a specified prefix symbol. It
+uses `Transcoders` from the [xcodec](https://git.sr.ht/~z0/xcodec) library,
+allowing for different types of bytestring data to be specified as type
+parameters.
 
-Multibase GitHub README example in GHCI:
+Multibase GitHub [README example](
+https://github.com/multiformats/multibase#multibase-by-example) in GHCI:
 ```haskell
 λ> {-# LANGUAGE OverloadedStrings #-}
 λ> import MultiFormats.MultiBase.DigitTranscoder (decodeFromPrefix)
@@ -63,20 +60,16 @@
 Just "Multibase is awesome! \\o/"
 ```
 
-- Multibase specification - [https://github.com/multiformats/multibase](
-https://github.com/multiformats/multibase)
-- Multibase example - [
-https://github.com/multiformats/multibase#multibase-by-example](
-https://github.com/multiformats/multibase#multibase-by-example)
-
 `multicodec` - Magic number specifications
 ------------------------------------------
 
 Provides lookup table and query functions for codecs defined from multiformats
-multicodec. These are magic numbers that represent certain data encoded within
-CIDs, mulithash and other related projects. This module has code which
-is generated by a python script in the [ipfshs](https://todo.sr.ht/~z0/ipfshs)
-repo, and is automatically generated from CSV.
+[multicodec](https://github.com/multiformats/multicodec). These are magic
+number identifiers that represent certain data encoded within CIDs, mulithash
+and other related projects. This module is generated by a Python script in the
+[ipfshs](https://todo.sr.ht/~z0/ipfshs) repo by using the [CSV file](
+https://github.com/multiformats/multicodec/blob/master/table.csv) provided from
+the multicodec GitHub.
 
 Example of looking up codecs:
 ```haskell
@@ -91,19 +84,14 @@
 Nothing
 ```
 
-- Multicodec specification - [https://github.com/multiformats/multicodec](
-https://github.com/multiformats/multicodec)
-- Multicodec value table - [
-https://github.com/multiformats/multicodec/blob/master/table.csv](
-https://github.com/multiformats/multicodec/blob/master/table.csv)
-
 `multihash` - Multicodec hash function identifiers
 --------------------------------------------------
 
-Multihashes are a type of multicodec for identifying hash functions. This
-code provides a lookup table for hash functions from the multicodec module, and
-a way to get hash digests from specific functions over bytestrings, and to
-verify multicodec values as valid multihash codecs.
+[Multihashes](https://github.com/multiformats/multihash) are a type of
+multicodec for identifying hash functions. This module provides a lookup table
+for hash functions from the multicodec module, a way to get hash digests from
+specific functions over bytestrings, and to verify multicodec values as valid
+multihash codecs.
 
 Example of looking up hash functions and applying them:
 ```haskell
@@ -126,37 +114,30 @@
 "7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069"
 ```
 
-- Multihash specification - [https://github.com/multiformats/multihash](
-https://github.com/multiformats/multihash)
-- Multiformat's Golang implementation - [
-https://github.com/multiformats/go-multihash](
-https://github.com/multiformats/go-multihash)
-
 `varint` - Unsigned variable length integers
 --------------------------------------------
 
-Provides parsing and serialization for multiformats unsigned binary varints,
-with the special caveat from multiformats that requires them always to be
-minimally encoded, so this project also verifies that the varint inputs comply
-with the rules of the multiformats specification.
+Provides parsing and serialization for unsigned binary varints, with the caveat
+from the multiformats specification that requires them always to be minimally
+encoded.
 
-Varint GitHub README example in GHCI using `packValue` from the [basesystems](
-https://git.sr.ht/~z0/basesystems) library to transfer constants into
-bytestrings. We can then use `extractVarInt` to get the varint representation
-from the bytes:
+Varint GitHub [README example](https://github.com/multiformats/unsigned-varint)
+in GHCI using `packValue` from the [xcodec](https://git.sr.ht/~z0/xcodec)
+library to transfer constants into bytestrings. We can then use `extractVarInt`
+to get the varint representation from the bytes:
 ```haskell
-λ> import Data.BaseSystem.BinaryTranscoder (packValue)
 λ> import Data.ByteString.Short (ShortByteString)
 λ> import MultiFormats.VarInt (VarInt, extractVarInt)
 λ> import MultiFormats.VarInt.Errors qualified as VarInt
-λ> -- Make alias so we don't get type warnings
+λ> import XCodec.Transcoder (packValue)
+λ> -- Alias to suppress type warnings
 λ> let packInteger x = packValue (x :: Integer)
 λ> -- 7-bit values fit into 1 byte:
 λ> extractVarInt (packInteger 0x01) :: VarInt.Okay (VarInt, ShortByteString)
 Right (1,"")
 λ> extractVarInt (packInteger 0x7f) :: VarInt.Okay (VarInt, ShortByteString)
 Right (127,"")
-λ> -- 8-bit and larger values have their MSB set until a zero MSB byte is found:
+λ> -- 8-bit and larger values have MSB=1 until a byte with MSB=0 is found:
 λ> extractVarInt (packInteger 0x8001) :: VarInt.Okay (VarInt, ShortByteString)
 Right (128,"")
 λ> extractVarInt (packInteger 0xff01) :: VarInt.Okay (VarInt, ShortByteString)
@@ -167,22 +148,31 @@
 Right (16384,"")
 ```
 
-- Varint specification - [https://github.com/multiformats/unsigned-varint](
-https://github.com/multiformats/unsigned-varint)
-
 Development
 -----------
 
-Unit tests are provided on the main [ipfshs repo](https://git.sr.ht/~z0/ipfshs),
-and bugs can be reported on [ipfshs ticket tracker](
-https://todo.sr.ht/~z0/ipfshs).
+This project is part of [ipfshs](https://sr.ht/~z0/ipfshs); unit tests are
+provided on the main page and bugs can be reported on its [ticket tracker](
+https://todo.sr.ht/~z0/ipfshs). Patches and pull requests can be submitted with
+[`git send-email`](https://git-send-email.io/). To build and test this project
+against all of ipfshs read [this](https://sr.ht/~z0/ipfshs/#development)
+section on setting up an ipfshs development environment.
 
+This project can also be built as a standalone library with [`cabal`](
+https://github.com/haskell/cabal#ways-to-get-the-cabal-install-binary).
+
+```shell
+$ git clone https://git.sr.ht/~z0/mfmts
+$ cd mfmts
+$ cabal build
+```
+
 Licensing
 ---------
 
-The `mfmts` project and its modules are free software and licensed under the
+The mfmts project and its modules are free software and licensed under the
 [AGPLv3](https://www.gnu.org/licenses/agpl-3.0.en.html) license. See
-[LICENSE.txt](LICENSE.txt).
+[`LICENSE.txt`](LICENSE.txt).
 
 Copyright © 2026 Zoey McBride | [zoeymcbride@mailbox.org](
 mailto:zoeymcbride@mailbox.org)
diff --git a/cid/MultiFormats/CID.hs b/cid/MultiFormats/CID.hs
--- a/cid/MultiFormats/CID.hs
+++ b/cid/MultiFormats/CID.hs
@@ -28,8 +28,6 @@
 import Data.List (intercalate)
 import Data.Maybe (fromJust)
 import Data.Text qualified as Text
-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)
-import Data.XCodec.BinaryTranscoder qualified as BXC
 import MultiFormats.CID.Component.Codec qualified as CID
 import MultiFormats.CID.Component.Decoder qualified as CID
 import MultiFormats.CID.Component.Hash qualified as CID
@@ -43,6 +41,8 @@
 import MultiFormats.MultiCodec (MultiCodec (..), resolveMultiCodec)
 import MultiFormats.MultiHash (MultiHash (..), resolveMultiHash)
 import MultiFormats.VarInt (VarInt)
+import XCodec.Transcoder (Transcoder)
+import XCodec.Transcoder qualified as XC
 
 -- | Defines the data-type for CID data.
 data CID = CID
@@ -113,18 +113,18 @@
 -- encoded string. Fails when there is extra bytes past the CID.
 instance Parser CID where
   parser cidstr = do
-    -- Decode to bytes based on the String's encoding. Use SBS as BXC because
+    -- Decode to bytes based on the String's encoding. Use SBS as XC because
     -- the bytestring is discarded after this function.
     CID.Decoder cidbytes <- parser cidstr :: Okay (CID.Decoder ShortByteString)
     -- Extracts the CID's data from bytes.
     (cid, trailing) <- extractor cidbytes
     -- Fail if there is any leftovers. Otherwise fully evaluate the CID.
-    if BXC.totalOctets trailing > 0
+    if XC.totalOctets trailing > 0
       then Left (InvalidData TrailingBytes)
       else Right $!! cid
 
 -- | Extracts a CID from a ByteString. Allows trailing bytes.
-instance (BinaryTranscoder t) => Extractor CID t where
+instance (Transcoder tc) => Extractor CID tc where
   extractor bytes = do
     -- First, extract the version from bytes
     (version, rest) <- extractor bytes
@@ -135,18 +135,18 @@
       CIDv1 -> extractCIDv1 rest
 
 -- | Applies the extraction after version# for CIDv0 was extracted.
-extractCIDv0 :: (BinaryTranscoder t) => Extraction CID t
+extractCIDv0 :: (Transcoder tc) => Extraction CID tc
 extractCIDv0 ondata
   -- Fail if there isn't enough bytes
   | totalbytes /= CID.v0HashBytes = Left (InvalidHash IncorrectLength)
   -- Create the CIDv0 from data
   | otherwise = Right (mkCIDv0 ciddata, rest)
   where
-    totalbytes = BXC.totalOctets ondata
-    (ciddata, rest) = BXC.splitOffset CID.v0HashBytes ondata
+    totalbytes = XC.totalOctets ondata
+    (ciddata, rest) = XC.splitOffset CID.v0HashBytes ondata
 
 -- | Applies the extraction after version# for CIDv1 was extracted.
-extractCIDv1 :: (BinaryTranscoder t) => Extraction CID t
+extractCIDv1 :: (Transcoder tc) => Extraction CID tc
 extractCIDv1 oncodec = do
   -- Extract the 1st MultiCodec from the bytes.
   (CID.Codec multicodec, onhash) <- extractor oncodec
@@ -190,16 +190,16 @@
 
 -- | Provides the contructor for CIDv0s, see:
 -- https://github.com/multiformats/cid?tab=readme-ov-file#cidv0
-mkCIDv0 :: (BinaryTranscoder t) => t -> CID
+mkCIDv0 :: (Transcoder tc) => tc -> CID
 mkCIDv0 digest =
   CID
     { cidVersion = CIDv0,
       cidDataCodec = codec "dag-pb",
       cidHashCodec = hash "sha2-256",
       cidHashSize = varlen digest,
-      cidHashBuilder = BXC.unpackSerial digest
+      cidHashBuilder = XC.unpackBuilder digest
     }
   where
     codec str = fromJust $!! resolveMultiCodec str
     hash str = fromJust $!! resolveMultiHash str
-    varlen bxc = fromIntegral $! BXC.totalOctets bxc
+    varlen xc = fromIntegral $! XC.totalOctets xc
diff --git a/cid/MultiFormats/CID/Component/Codec.hs b/cid/MultiFormats/CID/Component/Codec.hs
--- a/cid/MultiFormats/CID/Component/Codec.hs
+++ b/cid/MultiFormats/CID/Component/Codec.hs
@@ -8,7 +8,7 @@
 
 import Control.DeepSeq (NFData (..), force)
 import Data.Bifunctor (first)
-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)
+import XCodec.Transcoder (Transcoder)
 import MultiFormats.CID.Extractor (Extractor (extractor))
 import MultiFormats.MultiCodec (MultiCodec (MultiCodec))
 
@@ -20,5 +20,5 @@
   rnf (Codec mc) = rnf mc
 
 -- | Extracts the MultiCodec from VarInt in bytes and wraps in Codec.
-instance (BinaryTranscoder t) => Extractor Codec t where
+instance (Transcoder tc) => Extractor Codec tc where
   extractor bytes = first (force . Codec . MultiCodec) <$> extractor bytes
diff --git a/cid/MultiFormats/CID/Component/Decoder.hs b/cid/MultiFormats/CID/Component/Decoder.hs
--- a/cid/MultiFormats/CID/Component/Decoder.hs
+++ b/cid/MultiFormats/CID/Component/Decoder.hs
@@ -7,18 +7,18 @@
 module MultiFormats.CID.Component.Decoder (Decoder (Decoder)) where
 
 import Data.Text qualified as Text
-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)
 import MultiFormats.CID.Component.Version (isTextCIDv0)
 import MultiFormats.CID.Errors
 import MultiFormats.CID.Parser
 import MultiFormats.MultiBase.DigitTranscoder (hasValidPrefix)
 import MultiFormats.MultiBase.DigitTranscoder qualified as DXC
+import XCodec.Transcoder (Transcoder)
 
 -- | Implements decoding CID from String's base encoding.
-newtype Decoder b = Decoder b
+newtype Decoder t = Decoder t
 
 -- | Decodes a CID to bytes.
-instance (BinaryTranscoder b) => Parser (Decoder b) where
+instance (Transcoder tc) => Parser (Decoder tc) where
   parser str =
     let choosedecoder
           | Text.null str = Left (InvalidData EmptyCID)
diff --git a/cid/MultiFormats/CID/Component/Hash.hs b/cid/MultiFormats/CID/Component/Hash.hs
--- a/cid/MultiFormats/CID/Component/Hash.hs
+++ b/cid/MultiFormats/CID/Component/Hash.hs
@@ -6,16 +6,16 @@
 --   Stability   : experimental
 module MultiFormats.CID.Component.Hash (Hash (Hash)) where
 
-import Control.DeepSeq (force, NFData (..))
+import Control.DeepSeq (NFData (..), force)
+import Data.Bifunctor (first)
 import Data.ByteString.Builder (Builder)
-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)
-import Data.XCodec.BinaryTranscoder qualified as BXC
 import MultiFormats.CID.Component.Codec qualified as CID
 import MultiFormats.CID.Errors
 import MultiFormats.CID.Extractor (Extractor (extractor))
 import MultiFormats.MultiHash (MultiHash, resolveHashCodec)
 import MultiFormats.VarInt (VarInt)
-import Data.Bifunctor (first)
+import XCodec.Transcoder (Transcoder)
+import XCodec.Transcoder qualified as XC
 
 data Hash = Hash
   { -- | Stores the MultiCodec for the hash function used.
@@ -32,7 +32,7 @@
 
 -- | Extracts the MultiHash codec and hash digest via a varint size following
 -- the MultiHash codec.
-instance (BinaryTranscoder t) => Extractor Hash t where
+instance (Transcoder tc) => Extractor Hash tc where
   extractor bytes = do
     -- Get the CodecCode from the first varint
     (CID.Codec codec, onsize) <- extractor bytes
@@ -43,13 +43,13 @@
     case resolveHashCodec codec of
       Nothing -> Left (InvalidHash $ UnknownHashCodec codec)
       Just hash
-        | isize < BXC.totalOctets ondigest -> Left (InvalidHash IncorrectLength)
+        | isize < XC.totalOctets ondigest -> Left (InvalidHash IncorrectLength)
         | otherwise -> Right $ extractHashDigest hash usize ondigest
         where
           -- Gets the varint size as generic integral type
           isize = fromIntegral usize
           -- Extracts the hash data from the bytes
           extractHashDigest !multihash !size rest =
-            let (hashdata, final) = BXC.splitOffset isize rest
-                hashbuilder = BXC.unpackSerial hashdata
+            let (hashdata, final) = XC.splitOffset isize rest
+                hashbuilder = XC.unpackBuilder hashdata
              in first force (Hash multihash size hashbuilder, final)
diff --git a/cid/MultiFormats/CID/Component/Version.hs b/cid/MultiFormats/CID/Component/Version.hs
--- a/cid/MultiFormats/CID/Component/Version.hs
+++ b/cid/MultiFormats/CID/Component/Version.hs
@@ -20,11 +20,11 @@
 import Control.DeepSeq (NFData (..))
 import Data.Text (Text)
 import Data.Text qualified as Text
-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)
-import Data.XCodec.BinaryTranscoder qualified as BXC
 import MultiFormats.CID.Constants
 import MultiFormats.CID.Errors
 import MultiFormats.CID.Extractor (Extraction, Extractor (extractor))
+import XCodec.Transcoder (Transcoder)
+import XCodec.Transcoder qualified as XC
 
 -- | Implements available CID versions.
 data Version = CIDv0 | CIDv1 deriving (Show, Eq, Enum)
@@ -34,9 +34,9 @@
   rnf _ = ()
 
 -- | Extracts and validates the CID versioning information from bytes.
-instance (BinaryTranscoder t) => Extractor Version t where
+instance (Transcoder tc) => Extractor Version tc where
   extractor cidbytes =
-    case BXC.uncons cidbytes of
+    case XC.uncons cidbytes of
       Nothing -> Left (InvalidData EmptyCID)
       Just (magic, _)
         -- Only CIDv0 will start with 0x12, and it must be followed w/ a
@@ -47,7 +47,7 @@
         | otherwise -> extractVersion1 cidbytes
 
 -- | Performs extraction for CIDv1.
-extractVersion1 :: (BinaryTranscoder t) => Extraction Version t
+extractVersion1 :: (Transcoder tc) => Extraction Version tc
 extractVersion1 bytes =
   extractor bytes >>= \(varint1, rest) ->
     if invalidCIDv1 varint1
@@ -57,11 +57,11 @@
     invalidCIDv1 v1 = v1 /= v1FirstVarInt
 
 -- | Performs extraction for CIDv0.
-extractVersion0 :: (BinaryTranscoder t) => Extraction Version t
+extractVersion0 :: (Transcoder tc) => Extraction Version tc
 extractVersion0 ciddata =
-  let (lead, rest) = BXC.splitOffset 2 ciddata
-      total = BXC.totalOctets ciddata
-   in case BXC.unpackOctets lead of
+  let (lead, rest) = XC.splitOffset 2 ciddata
+      total = XC.totalOctets ciddata
+   in case XC.unpackOctets lead of
         [b1, b2]
           | invalidCIDv0 b1 b2 total -> Left (InvalidEncoding MalformedCIDv0)
           | otherwise -> Right (CIDv0, rest)
diff --git a/cid/MultiFormats/CID/Extractor.hs b/cid/MultiFormats/CID/Extractor.hs
--- a/cid/MultiFormats/CID/Extractor.hs
+++ b/cid/MultiFormats/CID/Extractor.hs
@@ -14,21 +14,21 @@
   )
 where
 
-import Data.Bifunctor (first)
 import Control.DeepSeq (force)
-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)
+import Data.Bifunctor (first)
 import MultiFormats.CID.Errors
 import MultiFormats.VarInt (VarInt, extractVarInt)
+import XCodec.Transcoder (Transcoder)
 
 -- | Alias for `extractor` method. Extracts `a` from ByteString.
 type Extraction a t = t -> Okay (a, t)
 
 -- | Generic function signature for extracting CID components.
-class (BinaryTranscoder t) => Extractor a t where
-  extractor :: t -> Okay (a, t)
+class (Transcoder tc) => Extractor a tc where
+  extractor :: tc -> Okay (a, tc)
 
 -- | Extractor for VarInts in CID data. Converts VarInt.Error to CID.Error.
-instance (BinaryTranscoder t) => Extractor VarInt t where
+instance (Transcoder tc) => Extractor VarInt tc where
   extractor =
     -- Either reconstruct the either or strictly evaulate into the context.
     either (Left . InvalidVarInt) (Right . first force) . extractVarInt
diff --git a/mfmts.cabal b/mfmts.cabal
--- a/mfmts.cabal
+++ b/mfmts.cabal
@@ -1,5 +1,5 @@
 cabal-version: 3.0
-version:       1.2.0.0
+version:       1.2.0.1
 name:          mfmts
 build-type:    Simple
 author:        Zoey McBride
@@ -39,7 +39,7 @@
     build-depends:
         base >= 4.18 && < 5,
         basesystems ^>= 1.2,
-        xcodec ^>= 1.1,
+        xcodec ^>= 2.0,
         text >= 2.1 && < 2.2,
         array ^>= 0.5,
         bytestring ^>= 0.12,
diff --git a/multibase/MultiFormats/MultiBase/DigitSystems.hs b/multibase/MultiFormats/MultiBase/DigitSystems.hs
--- a/multibase/MultiFormats/MultiBase/DigitSystems.hs
+++ b/multibase/MultiFormats/MultiBase/DigitSystems.hs
@@ -26,77 +26,77 @@
 where
 
 import Data.Maybe (fromJust)
-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)
 import MultiFormats.MultiBase.DigitTranscoder (MultiBase, resolvePrefix)
+import XCodec.Transcoder (Transcoder)
 
 -- | Creates the multibase from Char, and crashes if Char is an invalid prefix.
-mk :: (BinaryTranscoder bxc) => Char -> MultiBase bxc
+mk :: (Transcoder tc) => Char -> MultiBase tc
 mk = fromJust . resolvePrefix
 
 -- | Binary has prefix "0".
-multibase2 :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase2 :: (Transcoder tc) => MultiBase tc
 multibase2 = mk '0'
 
 -- | Decimal has prefix "9".
-multibase10 :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase10 :: (Transcoder tc) => MultiBase tc
 multibase10 = mk '9'
 
 -- | Hex-lower has prefix "f".
-multibase16lower :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase16lower :: (Transcoder tc) => MultiBase tc
 multibase16lower = mk 'f'
 
 -- | Hex-upper has prefix "F".
-multibase16upper :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase16upper :: (Transcoder tc) => MultiBase tc
 multibase16upper = mk 'F'
 
 -- | base32lower (no pad) has prefix "b".
-multibase32lowerNP :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase32lowerNP :: (Transcoder tc) => MultiBase tc
 multibase32lowerNP = mk 'b'
 
 -- | base32uppper (no pad) has prefix "B".
-multibase32upperNP :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase32upperNP :: (Transcoder tc) => MultiBase tc
 multibase32upperNP = mk 'B'
 
 -- | base32lower (with pad) has prefix "c".
-multibase32lower :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase32lower :: (Transcoder tc) => MultiBase tc
 multibase32lower = mk 'c'
 
 -- | base32upper (with pad) has prefix "C".
-multibase32upper :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase32upper :: (Transcoder tc) => MultiBase tc
 multibase32upper = mk 'C'
 
 -- | Hex-base32lower (no pad) has prefix "v".
-multibase32hexlowerNP :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase32hexlowerNP :: (Transcoder tc) => MultiBase tc
 multibase32hexlowerNP = mk 'v'
 
 -- | Hex-base32upper (no pad) has prefix "V".
-multibase32hexupperNP :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase32hexupperNP :: (Transcoder tc) => MultiBase tc
 multibase32hexupperNP = mk 'V'
 
 -- | Hex-base32lower (with pad) has prefix "t".
-multibase32hexlower :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase32hexlower :: (Transcoder tc) => MultiBase tc
 multibase32hexlower = mk 't'
 
 -- | Hex-base32upper (with pad) has prefix "T".
-multibase32hexupper :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase32hexupper :: (Transcoder tc) => MultiBase tc
 multibase32hexupper = mk 'T'
 
 -- | Bitcoin base58 has prefix "z".
-multibase58btc :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase58btc :: (Transcoder tc) => MultiBase tc
 multibase58btc = mk 'z'
 
 -- | base64 (no pad) has prefix "m".
-multibase64NP :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase64NP :: (Transcoder tc) => MultiBase tc
 multibase64NP = mk 'm'
 
 -- | base64 (with pad) has prefix "M".
-multibase64 :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase64 :: (Transcoder tc) => MultiBase tc
 multibase64 = mk 'M'
 
 -- | base64url (no pad) has prefix "u".
-multibase64urlNP :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase64urlNP :: (Transcoder tc) => MultiBase tc
 multibase64urlNP = mk 'u'
 
 -- | base64url (with pad) has prefix "U".
-multibase64url :: (BinaryTranscoder bxc) => MultiBase bxc
+multibase64url :: (Transcoder tc) => MultiBase tc
 multibase64url = mk 'U'
diff --git a/multibase/MultiFormats/MultiBase/DigitTranscoder.hs b/multibase/MultiFormats/MultiBase/DigitTranscoder.hs
--- a/multibase/MultiFormats/MultiBase/DigitTranscoder.hs
+++ b/multibase/MultiFormats/MultiBase/DigitTranscoder.hs
@@ -31,36 +31,36 @@
 import Data.Maybe (fromMaybe)
 import Data.Text (Text)
 import Data.Text qualified as Text
-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)
+import XCodec.Transcoder (Transcoder)
 
 -- | Stores a multibase basesystem's prefix and its implementations for
 -- digitDecoder/digitEncoder from Data.BaseSystems.DigitTranscoder.
-data MultiBase bxc = MultiBase
+data MultiBase t = MultiBase
   { -- | The name of the basesystem for displaying in show (prepends "multi").
     multibaseName :: String,
     -- | The basesystem's idenitifying symbol.
     multibasePrefix :: Alpha.Symbol,
     -- | Encodes the binary transcoder to Text.
-    multibaseEncoder :: bxc -> Text,
+    multibaseEncoder :: t -> Text,
     -- | Decodes the binary transcoder from Text.
-    multibaseDecoder :: Text -> Maybe bxc
+    multibaseDecoder :: Text -> Maybe t
   }
 
 -- | Implements equality for multibase on prefixes.
-instance Eq (MultiBase bxc) where
+instance Eq (MultiBase t) where
   (==) = (==) `on` multibasePrefix
 
 -- | Implements ordering for multibase on prefixes.
-instance Ord (MultiBase bxc) where
+instance Ord (MultiBase t) where
   compare = compare `on` multibasePrefix
 
 -- | Prepends multi to the basesystem name.
-instance Show (MultiBase bxc) where
+instance Show (MultiBase t) where
   show mb = "multi" ++ multibaseName mb
 
 -- | Implements a DigitTranscoder for all MulitBases parameterized by
--- BinaryTranscoder.
-instance (BinaryTranscoder bxc) => DigitTranscoder (MultiBase bxc) bxc where
+-- Transcoder.
+instance (Transcoder tc) => DigitTranscoder (MultiBase tc) tc where
   -- digitEncoder: Use the encoder provided in the MultiBase data.
   digitEncoder = multibaseEncoder
 
@@ -69,14 +69,14 @@
 
 -- | Provides decoder for MultiBase strings with any implemented prefix
 -- character.
-decodeFromPrefix :: (BinaryTranscoder bxc) => Text -> Maybe bxc
+decodeFromPrefix :: (Transcoder tc) => Text -> Maybe tc
 decodeFromPrefix text = do
   (prefix, rest) <- Text.uncons text
   decode <- multibaseDecoder <$> resolvePrefix prefix
   decode rest
 
 -- | Decodes for CIDv0 from base58btc w/o MultiBase prefix.
-decodeCIDv0 :: (BinaryTranscoder bxc) => Text -> Maybe bxc
+decodeCIDv0 :: (Transcoder tc) => Text -> Maybe tc
 decodeCIDv0 = digitDecoder Digits.base58btc
 
 -- | Checks if the Text has a valid prefix character.
@@ -92,11 +92,11 @@
     lookupTable = prefixSymbolTable :: IntMap (MultiBase ByteString)
 
 -- | Resolves a MultiBase system from the first Symbol in a String.
-resolveTextPrefix :: (BinaryTranscoder bxc) => Text -> Maybe (MultiBase bxc)
+resolveTextPrefix :: (Transcoder tc) => Text -> Maybe (MultiBase tc)
 resolveTextPrefix text = Text.uncons text >>= \(ch, _) -> resolvePrefix ch
 
 -- | Resolves a MultiBase system from a basesystem prefix Symbol.
-resolvePrefix :: (BinaryTranscoder bxc) => Alpha.Symbol -> Maybe (MultiBase bxc)
+resolvePrefix :: (Transcoder tc) => Alpha.Symbol -> Maybe (MultiBase tc)
 resolvePrefix prefix = ord prefix `IntMap.lookup` prefixSymbolTable
 
 -- | Creates the lookup table between prefix symbols and multibase systems.
@@ -106,7 +106,7 @@
 -- https://github.com/multiformats/multibase/blob/master/multibase.csv
 -- Data.Map on IntMap performance:
 -- https://hackage-content.haskell.org/package/containers-0.8/docs/Data-Map.html
-prefixSymbolTable :: (BinaryTranscoder bxc) => IntMap (MultiBase bxc)
+prefixSymbolTable :: (Transcoder tc) => IntMap (MultiBase tc)
 prefixSymbolTable =
   IntMap.fromList
     [ mk '0' Digits.base2,
@@ -134,10 +134,10 @@
 -- | Creates a multibase system from a prefix and digit transcoder
 -- implementation.
 mkMultiBase ::
-  (BinaryTranscoder bxc, DigitTranscoder dxc bxc, Show dxc) =>
+  (Transcoder tc, DigitTranscoder dc tc, Show dc) =>
   Alpha.Symbol ->
-  dxc ->
-  MultiBase bxc
+  dc ->
+  MultiBase tc
 mkMultiBase prefix digits =
   MultiBase
     { multibaseName = show digits,
diff --git a/multicodec/MultiFormats/MultiCodec.hs b/multicodec/MultiFormats/MultiCodec.hs
--- a/multicodec/MultiFormats/MultiCodec.hs
+++ b/multicodec/MultiFormats/MultiCodec.hs
@@ -24,8 +24,8 @@
 import Data.Map qualified as LazyMap
 import Data.Maybe (fromMaybe)
 import Data.Text qualified as Text
-import Data.XCodec.BinaryTranscoder (packValueBE)
 import MultiFormats.VarInt (VarInt)
+import XCodec.Transcoder (packValueBE)
 
 -- | Represents MultiCodec code.
 newtype MultiCodec = MultiCodec {multiCodecValue :: VarInt} deriving (Eq, Ord)
diff --git a/multihash/MultiFormats/MultiHash.hs b/multihash/MultiFormats/MultiHash.hs
--- a/multihash/MultiFormats/MultiHash.hs
+++ b/multihash/MultiFormats/MultiHash.hs
@@ -32,13 +32,13 @@
 import Data.Map qualified as LazyMap
 import Data.Maybe (fromMaybe, mapMaybe)
 import Data.Text qualified as Text
-import Data.XCodec.BinaryTranscoder (packValueBE)
 import Foreign.ForeignPtr (newForeignPtr)
 import Foreign.Marshal.Alloc (finalizerFree)
 import Foreign.Marshal.Array (copyArray, mallocArray)
 import GHC.IO (unsafePerformIO)
 import MultiFormats.MultiCodec (MultiCodec (..))
 import MultiFormats.MultiCodec qualified as MC
+import XCodec.Transcoder (packValueBE)
 
 -- | Alias for the type of function signture we want from a hash function.
 type HashFunction = Builder -> LazyByteString
diff --git a/varint/MultiFormats/VarInt.hs b/varint/MultiFormats/VarInt.hs
--- a/varint/MultiFormats/VarInt.hs
+++ b/varint/MultiFormats/VarInt.hs
@@ -21,9 +21,9 @@
 import Data.ByteString.Builder qualified as Builder
 import Data.ByteString.Short qualified as SBS
 import Data.Word (Word16, Word64, Word8)
-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)
-import Data.XCodec.BinaryTranscoder qualified as BXC
 import MultiFormats.VarInt.Errors (Error (..), Okay)
+import XCodec.Transcoder (Transcoder)
+import XCodec.Transcoder qualified as XC
 
 -- | VarInt spec uses unsigned 64 bit integers.
 type VarInt = Word64
@@ -55,30 +55,30 @@
 
 -- | Splits ByteString into it's first occurring VarInt and the remaining
 -- ByteString after.
-spanVarInt :: (BinaryTranscoder t) => t -> Okay (t, t)
-spanVarInt bxc
+spanVarInt :: (Transcoder tc) => tc -> Okay (tc, tc)
+spanVarInt xc
   -- Fail if empty bytes.
-  | BXC.null bxc = Left EmptyBytes
+  | XC.null xc = Left EmptyBytes
   -- Otherwise, collect the bytes with MSB=1.
   | otherwise =
-      case BXC.spanOctetsTop isMSB1 bxc of
+      case XC.spanOctetsTop isMSB1 xc of
         -- The varint is the leading bytes with the MSB=1 and a final
         -- terminating byte with MSB=0.
         (msb1s, msb0s)
           -- Verify if a final byte exists.
-          | BXC.null msb0s -> Left MissingTermination
+          | XC.null msb0s -> Left MissingTermination
           -- The loop invariant ensures &msb1s + 1 has MSB=0, so compute this
           -- offset and split the data there.
           | otherwise ->
-              let nulloffset = BXC.totalOctets msb1s + 1
-               in Right (BXC.splitOffset nulloffset bxc)
+              let nulloffset = XC.totalOctets msb1s + 1
+               in Right (XC.splitOffset nulloffset xc)
   where
     -- Checks if the most-significant bit (MSB) is set to 1
     isMSB1 !byte = (byte .&. msb1) /= 0
 
 -- | Concats the lower 7 bits from bytes into single int value.
-buildVarInt :: (BinaryTranscoder t) => t -> VarInt
-buildVarInt = foldr build 0 . BXC.unpackOctets
+buildVarInt :: (Transcoder tc) => tc -> VarInt
+buildVarInt = foldr build 0 . XC.unpackOctets
   where
     -- Shifts the accumulator 7 bits (1 byte minus MSB value) and ORs the
     -- current byte into place, and remove the MSB set bit.
@@ -88,23 +88,23 @@
 -- of varints, (ie, we can fit 2 bytes of 7 bits into 1 byte of 7 bits). The
 -- only case of this is when a final 0x8100 should be a 0x79... I think!
 {-# INLINE nonMinimal #-}
-nonMinimal :: (BinaryTranscoder bxc) => bxc -> Bool
+nonMinimal :: (Transcoder tc) => tc -> Bool
 nonMinimal vardata = last16bits == invalidsuffix
   where
     -- Puts the last two bytes of the transcoder into a Word16.
-    last16bits = fromIntegral $! BXC.unpackValueBE (BXC.takeOctetsEnd 2 vardata)
+    last16bits = fromIntegral $! XC.unpackValueBE (XC.takeOctetsEnd 2 vardata)
     -- This value is the same to the value from bytes 0x7F, so it's not minimal
     invalidsuffix = (fromIntegral msb1lsb1 :: Word16) .<<. 8
 
 -- | Checks if a VarInt encoded ByteString overflows a Word64.
 {-# INLINE aboveCapacity #-}
-aboveCapacity :: (BinaryTranscoder t) => t -> Bool
+aboveCapacity :: (Transcoder tc) => tc -> Bool
 aboveCapacity vardata =
-  let wholelen = BXC.totalOctets vardata
+  let wholelen = XC.totalOctets vardata
    in not (1 <= wholelen && wholelen <= bytesCapacity)
 
 -- | Extracts the first minimally encoded varint from a ByteString.
-extractVarInt :: (BinaryTranscoder t) => t -> Okay (VarInt, t)
+extractVarInt :: (Transcoder tc) => tc -> Okay (VarInt, tc)
 extractVarInt = spanVarInt >=> spanBuild
   where
     -- Verifies the result from running spanVarInt