py-multibase ↔ go-multibase Feature Parity Analysis

[sumanjeet0012]

py-multibase Feature Parity Analysis

Date: 2026-07-05
Python version analyzed: py-multibase v2.0.0
Go version analyzed: go-multibase v0.3.0
Source: py-multibase · go-multibase

---

Table of Contents

1. Executive Summary
2. Architecture Comparison
3. Feature-by-Feature Gap Analysis
   • 3.1 Supported Encodings
   • 3.2 Core Encode / Decode API
   • 3.3 Encoder Type
   • 3.4 Encoding Lookup & Introspection
   • 3.5 Error Handling
   • 3.6 CLI Tool
   • 3.7 Testing, Spec Compliance & Benchmarks
4. Feature Matrix Summary
5. Phased Roadmap
   • Phase 1 – Correctness Fixes & Core API Gaps
   • Phase 2 – Encoder Parity & API Enrichment
   • Phase 3 – Spec Compliance & Testing Hardening
   • Phase 4 – CLI Tool & Performance
6. Appendix – Encoding Implementation Details

---

Executive Summary

The Python implementation (py-multibase) supports a solid set of 24 encodings including some that Go does not implement (base8, base10, base32z). The Go implementation (go-multibase) is leaner with 21 encodings but has stronger tooling: a typed Encoder with EncoderByName lookup (by name or single-character prefix), a CLI transcoding tool, official spec-compliance tests, benchmarks, and fuzz testing.

Area	Status
Core encode/decode	✅ Parity achieved
Encoding coverage	⚠️ Python has more encodings (base8, base10, base32z); Go defines Base45 constant but unimplemented
Encoder / EncoderByName	⚠️ Python Encoder lacks name-or-prefix lookup
MustNewEncoder	❌ Missing (not idiomatic in Python but useful as a strict factory)
Decode always returns encoding	⚠️ Python requires explicit return_encoding=True
CLI tool (multibase-conv)	❌ Entirely absent
Spec compliance tests	❌ No tests against official multibase.csv or test vectors
Benchmarks	❌ None
Fuzz testing	❌ None
Round-trip edge-case tests	❌ Missing (leading zeros, case-insensitive decode, 0xFF buffers)
Base256emoji unit tests	❌ Missing (alphabet count, uniqueness)

---

Architecture Comparison

Go Architecture

go-multibase/
├── multibase.go            # Encoding type, constants, Encode(), Decode(), maps
├── encoder.go              # Encoder, NewEncoder, MustNewEncoder, EncoderByName
├── base2.go                # Binary encode/decode helpers
├── base16.go               # Uppercase hex helper
├── base32.go               # Base32 codec variants (CI = case-insensitive)
├── base256emoji.go         # Emoji alphabet table + encode/decode
├── base256emoji_test.go    # Alphabet uniqueness & count tests
├── multibase_test.go       # Encode/Decode/RoundTrip tests + benchmarks
├── encoder_test.go         # Encoder/EncoderByName tests
├── spec_test.go            # Spec compliance + fuzz test
├── multibase-conv/
│   └── main.go             # CLI: decode → re-encode in new base
├── version.json            # v0.3.0
├── go.mod / go.sum
└── package.json

Dependencies: mr-tron/base58, multiformats/go-base32, multiformats/go-base36 — all optimised native Go libraries.

Python Architecture

py-multibase/
├── multibase/
│   ├── __init__.py         # Public API exports
│   ├── multibase.py        # Encoding namedtuple, ENCODINGS list, encode/decode, Encoder/Decoder
│   ├── converters.py       # BaseStringConverter, Base16/32/64/256Emoji converters
│   └── exceptions.py       # MultibaseError, UnsupportedEncodingError, etc.
├── tests/
│   └── test_multibase.py   # Encode/decode/is_encoded tests
├── pyproject.toml
└── ruff.toml

Dependencies: python-baseconv (generic arbitrary-base conversion), morphys (bytes/string helpers), six (Python 2/3 compat — no longer needed for Python 3.10+).

---

Feature-by-Feature Gap Analysis

3.1 Supported Encodings

Encoding	Code	Go (EncodingToStr)	Python (ENCODINGS)	Notes
identity	0x00	✅	✅
base2	'0'	✅	✅
base8	'7'	⚠️ Constant only, not implemented	✅	Python is MORE complete
base10	'9'	⚠️ Constant only, not implemented	✅	Python is MORE complete
base16	'f'	✅	✅
base16upper	'F'	✅	✅
base32	'b'	✅	✅
base32upper	'B'	✅	✅
base32pad	'c'	✅	✅
base32padupper	'C'	✅	✅
base32hex	'v'	✅	✅
base32hexupper	'V'	✅	✅
base32hexpad	't'	✅	✅
base32hexpadupper	'T'	✅	✅
base32z	'h'	❌ Not present	✅	Python is MORE complete
base36	'k'	✅	✅
base36upper	'K'	✅	✅
base58btc	'z'	✅	✅
base58flickr	'Z'	✅	✅
base64	'm'	✅	✅
base64pad	'M'	✅	✅
base64url	'u'	✅	✅
base64urlpad	'U'	✅	✅
base256emoji	'🚀'	✅	✅
base45	'R'	⚠️ Constant only, not implemented	❌ Not present	Neither implemented

Summary: Python supports 24 encodings; Go supports 21. Python leads on base8, base10, base32z. Go defines Base45 as a constant but doesn't implement it; Python doesn't mention it at all.

3.2 Core Encode / Decode API

Feature	Go	Python	Gap?
Encode(base, data) → string	✅ Encode(Encoding, []byte) (string, error)	✅ encode(encoding, data) → bytes	No
Decode(data) → encoding + bytes	✅ Decode(string) (Encoding, []byte, error) — always returns encoding	⚠️ decode(data) → bytes (encoding only with return_encoding=True)	YES (default behaviour)
Empty string decode	✅ Returns explicit error	⚠️ Likely IndexError or InvalidMultibaseStringError	YES (no explicit check)
Return type	Go: string	Python: bytes	Design choice (both valid)
Encoding param type	Go: Encoding (int constant)	Python: str (name)	Design choice

3.2.1 Empty-string / zero-length handling

Go explicitly checks:

if len(data) == 0 {
    return 0, nil, fmt.Errorf("cannot decode multibase for zero length string")
}

Python has no equivalent guard — an empty b"" will reach get_codec which tries data[:1] and either raises IndexError (unlikely since slicing b""[:1] yields b"") or falls through to a KeyError wrapped in InvalidMultibaseStringError. This works but is less explicit.

3.2.2 Decode always returns encoding

Go's Decode signature always returns the detected encoding as the first return value. Python makes this opt-in:

# Current
decoded = decode(data)                              # bytes only
encoding, decoded = decode(data, return_encoding=True)  # tuple

# Go equivalent (always returns encoding)
enc, decoded, err := multibase.Decode(data)

Gap: Python's default hides the encoding. For Go parity, the default should arguably return both.

3.3 Encoder Type

Feature	Go Encoder	Python Encoder	Gap?
Create by encoding constant	✅ NewEncoder(base Encoding)	❌ Only by name	YES
Create by name string	✅ EncoderByName(str)	❌ Not directly	YES
Create by single-char prefix	✅ EncoderByName("f") → base16 encoder	❌ Not supported	YES
Panic-on-invalid constructor	✅ MustNewEncoder(base)	❌ Not present	YES (niche)
Encode(data) method	✅ Returns string (no error, pre-validated)	✅ Returns bytes	No
Encoding() accessor	✅ Encoder.Encoding() Encoding	⚠️ encoder.encoding (string name, not code)	YES (returns name not code)
Pre-validated (no error on encode)	✅	⚠️ Validated at construction	Effectively same

Key missing feature: EncoderByName which accepts either the human-readable name ("base16") or the single-character multibase prefix ("f") and returns an Encoder. This is very useful for CLI tools and configuration-driven encoding.

3.4 Encoding Lookup & Introspection

Feature	Go	Python	Gap?
EncodingToStr map (code → name)	✅	✅ ENCODINGS_LOOKUP (code → Encoding)	No
Encodings map (name → code)	✅	✅ ENCODINGS_LOOKUP (name → Encoding)	No
is_encoded(data)	❌ Not present	✅	No (Python extra)
is_encoding_supported(name)	❌ Not present	✅	No (Python extra)
list_encodings()	❌ Not present	✅	No (Python extra)
get_encoding_info(name)	❌ Not present	✅	No (Python extra)
get_codec(data) → codec info	❌ Not present	✅	No (Python extra)
Decoder / ComposedDecoder	❌ Not present	✅	No (Python extra)
decode(data, return_encoding=True)	❌ Not present (always returned)	✅	No (Python extra)

Python has significantly more introspection and utility APIs. Go is more minimal and expects users to work directly with the EncodingToStr / Encodings maps.

3.5 Error Handling

Go Error	Python Equivalent	Gap?
ErrUnsupportedEncoding	UnsupportedEncodingError	No
fmt.Errorf("cannot decode ... zero length string")	No dedicated error for empty string	YES (minor)
fmt.Errorf("unsupported multibase encoding: %d")	UnsupportedEncodingError	No
fmt.Errorf("empty multibase encoding")	No dedicated error	YES (minor)
base256emojiCorruptInputError{index, char}	Generic ValueError / DecodingError	YES (no index info)
—	MultibaseError (base)	Python extra
—	InvalidMultibaseStringError	Python extra
—	DecodingError	Python extra

3.6 CLI Tool

Feature	Go multibase-conv	Python	Gap?
CLI binary	✅ multibase-conv <new-base> <multibase-str>...	❌ Missing	YES
Decode then re-encode	✅ Decode input → encode in new base	❌	YES
Multiple inputs	✅ Processes all args	❌	YES
Error reporting	✅ Stderr + exit code 1	❌	YES

The Go CLI is simple but useful for quick transcoding:

multibase-conv z f796563206d616e692021   # base16 → base58btc

3.7 Testing, Spec Compliance & Benchmarks

Feature	Go	Python	Gap?
Encode test vectors	✅ encodedSamples map (all encodings, sample text)	✅ TEST_FIXTURES (many encodings, varied inputs)	No
Decode test vectors	✅ Same map	✅ Same fixtures	No
Spec compliance: multibase.csv	✅ TestSpec — validates encoding names/codes against official table	❌	YES
Spec test vectors: spec/tests/*.csv	✅ TestSpecVectors — encode + decode against official vectors	❌	YES
Fuzz testing	✅ FuzzDecode seeded with spec vectors	❌	YES
Round-trip with random data	✅ 137+16 byte buffer, tests from full buffer down to 1 byte	❌	YES
Leading-zeros round-trip	✅ 16 leading zero bytes, verifies preservation	❌	YES
0xFF overflow round-trip	✅ 131-byte 0xFF buffer, tests all lengths	❌	YES
Case-insensitive decode	✅ Tampered case swaps for case-insensitive codecs	❌	YES
Invalid input rejection	✅ Tests low-unicode, emoji, punctuation, high-latin1 for every encoding	❌	YES
Buffer non-modification check	✅ Verifies input buffer not mutated	❌	YES
Empty string decode test	✅ Explicit	❌	YES
Base256emoji alphabet count	✅ TestBase256EmojiAlphabet	❌	YES
Base256emoji uniqueness	✅ TestBase256EmojiUniq	❌	YES
BenchmarkEncode	✅ Per-encoding benchmarks	❌	YES
BenchmarkDecode	✅ Per-encoding benchmarks	❌	YES
BenchmarkRoundTrip	✅ Per-encoding benchmarks	❌	YES
Encoder tests	✅ TestEncoder, TestInvalidCode, TestInvalidName	✅ Basic test_encoder_class	No
Encoding map round-trip	✅ TestMap	❌	YES (minor)

---

Feature Matrix Summary

#	Feature	Priority	Status
1	EncoderByName(name_or_prefix)	High	❌ Missing
2	Encoder constructible by code constant	Medium	❌ Only by name
3	Encoder.encoding returns code (not just name)	Medium	⚠️ Returns name string
4	MustNewEncoder (strict factory)	Low	❌ Missing
5	decode() returns encoding by default	Medium	⚠️ Opt-in via parameter
6	Empty-string explicit error in decode()	Low	⚠️ Implicit
7	base256emojiCorruptInputError with index	Low	❌ Generic error
8	CLI tool (multibase-conv)	Medium	❌ Missing
9	Spec compliance tests (multibase.csv)	High	❌ Missing
10	Spec test vectors (spec/tests/*.csv)	High	❌ Missing
11	Fuzz testing (FuzzDecode)	Low	❌ Missing
12	Round-trip tests (random, leading zeros, 0xFF)	High	❌ Missing
13	Invalid-input rejection tests	Medium	❌ Missing
14	Case-insensitive decode test	Medium	❌ Missing
15	Base256emoji alphabet tests	Low	❌ Missing
16	Benchmark suite	Medium	❌ Missing
17	Encoding map round-trip test	Low	❌ Missing
18	Base45 encoding	Low	❌ Neither implements
19	Remove stale six dependency	Low	⚠️ Still listed
20	version.json	Low	❌ Missing

---

Phased Roadmap

Phase 1 – Correctness Fixes & Core API Gaps

Goal: Fix correctness issues and add the most important missing APIs.

Estimated effort: 1 week

1.1 Add EncoderByName function

Port Go's EncoderByName which accepts either a human-readable name ("base16") or a single-character multibase prefix ("f"):

def encoder_by_name(str_key: str) -> Encoder:
    """Create an encoder from a string — either the encoding name or single-character prefix.

    >>> encoder_by_name("base16")    # by name
    >>> encoder_by_name("f")         # by prefix character
    """
    if not str_key:
        raise UnsupportedEncodingError("empty multibase encoding")

    # Try as single-character prefix (including multi-byte emoji for base256emoji)
    if str_key in ENCODINGS_LOOKUP:
        codec = ENCODINGS_LOOKUP[str_key]
        return Encoder(codec.encoding)

    # Try as encoding name
    if str_key in ENCODINGS_LOOKUP:
        return Encoder(str_key)

    raise UnsupportedEncodingError(f"unsupported multibase encoding: {str_key}")

1.2 Make Encoder constructible by code constant

class Encoder:
    def __init__(self, encoding):
        # Accept string name, bytes code, or Encoding namedtuple
        if isinstance(encoding, bytes):
            if encoding in ENCODINGS_LOOKUP:
                self._codec = ENCODINGS_LOOKUP[encoding]
                self.encoding = self._codec.encoding
            else:
                raise UnsupportedEncodingError(...)
        elif isinstance(encoding, Encoding):
            ...
        else:
            ...  # existing name-based lookup

1.3 Add encoding_code property to Encoder

class Encoder:
    @property
    def encoding_code(self) -> bytes:
        """Return the multibase prefix code (like Go's Encoder.Encoding())."""
        return self._codec.code

1.4 Explicit empty-string check in decode()

def decode(data, return_encoding=False):
    data = ensure_bytes(data, "utf8")
    if len(data) == 0:
        raise InvalidMultibaseStringError("cannot decode multibase for zero length string")
    ...

1.5 Add base256emoji corrupt-input error with index

class Base256EmojiDecodingError(DecodingError):
    def __init__(self, index: int, char: str):
        super().__init__(
            f"illegal base256emoji data at input byte {index}, char: '{char}'"
        )
        self.index = index
        self.char = char

---

Phase 2 – Encoder Parity & API Enrichment

Goal: Full parity with Go's Encoder type and add useful utilities.

Estimated effort: 3–5 days

2.1 Add transcode() utility

Mirroring Go's multibase-conv functionality:

def transcode(data: bytes | str, new_encoding: str) -> bytes:
    """Decode a multibase string and re-encode it in a new encoding.

    >>> transcode(b"f796563206d616e692021", "base58btc")
    b'z7paNL19xttacUY'
    """
    decoded = decode(data)
    return encode(new_encoding, decoded)

2.2 Add MustNewEncoder equivalent (strict factory)

def must_new_encoder(encoding: str) -> Encoder:
    """Like Encoder() but raises immediately on invalid input (useful at module init)."""
    return Encoder(encoding)  # already raises UnsupportedEncodingError

2.3 Add case-insensitive base32 decode verification

Verify that the Python Base32StringConverter properly handles case-insensitive input. Go uses NewEncodingCI which accepts both upper and lower. The Python implementation uses self.digits.index(byte_) which is case-sensitive — this means decode("bIRSWGZLOORZGC3DJPJSSAZLWMVZHS5DINFXGOIJBEE") would fail for base32 (lowercase digits).

Fix: Make base32 decode case-insensitive regardless of the encoding variant:

class Base32StringConverter(BaseByteStringConverter):
    def decode(self, bytes_):
        # Normalize to the alphabet's case before decoding
        if isinstance(bytes_, bytes):
            bytes_ = bytes_.lower() if not self.digits[0].isupper() else bytes_.upper()
        return super()._decode_bytes(...)

2.4 Add base64url / base64urlpad round-trip verification

Verify that URL-safe base64 variants produce correct output matching Go's base64.RawURLEncoding / base64.URLEncoding.

2.5 Remove stale six dependency

The pyproject.toml lists six>=1.10.0,<2.0 as a dependency. Since the project requires Python ≥3.10, six is unnecessary. Remove it and verify morphys doesn't re-introduce it transitively.

---

Phase 3 – Spec Compliance & Testing Hardening

Goal: Add official spec compliance tests and harden the test suite to match Go's rigour.

Estimated effort: 1–2 weeks

3.1 Add official multibase spec as a git submodule

git submodule add https://github.com/multiformats/multibase spec

This provides:

• spec/multibase.csv — the official encoding table
• spec/tests/*.csv — official test vectors

3.2 Implement TestSpec — validate encoding table

def test_spec_multibase_csv():
    """Every encoding in ENCODINGS must appear in the official multibase.csv with matching name."""
    with open("spec/multibase.csv") as f:
        reader = csv.reader(f)
        header = next(reader)
        spec_encodings = {}
        for row in reader:
            unicode_str, character, encoding_name, _, _ = row
            code = int(unicode_str.replace("U+", ""), 16)
            spec_encodings[code] = encoding_name

    for enc in ENCODINGS:
        code_ord = ord(enc.code.decode("utf-8")) if len(enc.code) == 1 else ...
        spec_name = spec_encodings.get(code_ord)
        if spec_name and spec_name != "none":
            assert spec_name == enc.encoding, f"{enc.encoding} != {spec_name}"

3.3 Implement TestSpecVectors — official test vectors

@pytest.mark.parametrize("test_file", glob.glob("spec/tests/*.csv"))
def test_spec_vectors(test_file):
    """Encode/decode against official test vectors."""
    with open(test_file) as f:
        reader = csv.reader(f)
        header = next(reader)
        test_value = header[1]  # The plaintext to encode
        decode_only = "non-canonical" in header[0]

        for encoding_name, expected in reader:
            encoder = Encoder(encoding_name)
            if not decode_only:
                actual = encoder.encode(test_value.encode())
                assert actual.decode() == expected
            # Always test decode
            _, decoded = decode(expected, return_encoding=True)
            assert decoded == test_value.encode()

3.4 Add round-trip tests with random data

Port Go's comprehensive round-trip test:

def test_roundtrip_random():
    """Round-trip random data (including leading zeros) through every encoding."""
    buf = b'\x00' * 16 + os.urandom(137)
    for enc in ENCODINGS:
        if enc.encoding == "identity":
            continue
        for i in range(len(buf)):
            chunk = buf[i:]
            encoded = encode(enc.encoding, chunk)
            decoded = decode(encoded)
            assert decoded == chunk, f"Round-trip failed for {enc.encoding} at offset {i}"

def test_roundtrip_0xff():
    """Round-trip all-0xFF buffer to catch overflow bugs."""
    buf = b'\xff' * 131
    for enc in ENCODINGS:
        if enc.encoding == "identity":
            continue
        for i in range(len(buf)):
            chunk = buf[i:]
            encoded = encode(enc.encoding, chunk)
            decoded = decode(encoded)
            assert decoded == chunk

3.5 Add invalid-input rejection tests

def test_invalid_input_rejection():
    """Every non-identity encoding should reject low-unicode, emoji, punctuation, high-latin1."""
    bad_inputs = ["\u00A0", "\U0001F4A8", "!", "\xA0"]
    for enc in ENCODINGS:
        if enc.encoding == "identity":
            continue
        for bad in bad_inputs:
            with pytest.raises(Exception):
                decode(enc.code.decode("utf-8") + bad)

3.6 Add case-insensitive decode tests

def test_case_insensitive_decode():
    """Case-insensitive codecs should decode regardless of input case."""
    data = b"Decentralize everything!!!"
    encoded = encode("base32", data)
    # Swap some characters to uppercase
    tampered = encoded[:5] + encoded[5:10].upper() + encoded[10:]
    decoded = decode(tampered)
    assert decoded == data

3.7 Add base256emoji alphabet tests

def test_base256emoji_alphabet_count():
    converter = Base256EmojiConverter()
    assert len(converter._EMOJI_ALPHABET) == 256

def test_base256emoji_alphabet_unique():
    converter = Base256EmojiConverter()
    assert len(set(converter._EMOJI_ALPHABET)) == 256

3.8 Add encoding map round-trip test

def test_encoding_maps_roundtrip():
    for enc in ENCODINGS:
        assert ENCODINGS_LOOKUP[enc.encoding] == enc
        assert ENCODINGS_LOOKUP[enc.code] == enc

3.9 Add fuzz testing

Using pytest-fuzz or hypothesis:

from hypothesis import given, strategies as st

@given(st.text(min_size=1, max_size=1000))
def test_fuzz_decode(data):
    """Decode should never crash, only raise appropriate errors."""
    try:
        decode(data)
    except (InvalidMultibaseStringError, DecodingError, UnsupportedEncodingError):
        pass  # Expected

---

Phase 4 – CLI Tool & Performance

Goal: Provide a CLI tool matching Go's multibase-conv and add benchmarks.

Estimated effort: 1 week

4.1 Create CLI entry point

# multibase/cli.py
import argparse
import sys
from .multibase import decode, encode

def main():
    parser = argparse.ArgumentParser(
        description="Convert multibase strings between encodings"
    )
    parser.add_argument("new_base", help="Target encoding (name or single-char prefix)")
    parser.add_argument("inputs", nargs="+", help="Multibase strings to convert")
    args = parser.parse_args()

    for input_str in args.inputs:
        try:
            _, data = decode(input_str, return_encoding=True)
            result = encode(args.new_base, data)
            print(result.decode("utf-8"))
        except Exception as e:
            print(f"error while decoding: {e}", file=sys.stderr)
            sys.exit(1)

Register as console script in pyproject.toml:

[project.scripts]
multibase-conv = "multibase.cli:main"

4.2 Add benchmark suite

Using pytest-benchmark:

# tests/benchmarks/test_benchmarks.py
import pytest
from multibase import encode, decode, ENCODINGS

BENCH_DATA = b"Decentralize everything!!!"

@pytest.mark.parametrize("enc", [e.encoding for e in ENCODINGS])
def test_bench_encode(benchmark, enc):
    benchmark(encode, enc, BENCH_DATA)

@pytest.mark.parametrize("enc", [e.encoding for e in ENCODINGS])
def test_bench_decode(benchmark, enc):
    encoded = encode(enc, BENCH_DATA)
    benchmark(decode, encoded)

@pytest.mark.parametrize("enc", [e.encoding for e in ENCODINGS])
def test_bench_roundtrip(benchmark, enc):
    def roundtrip():
        return decode(encode(enc, BENCH_DATA))
    benchmark(roundtrip)

4.3 Add version.json

{
  "version": "v2.0.0"
}

4.4 Performance audit: Replace python-baseconv for hot paths

The current BaseStringConverter uses python-baseconv which does arbitrary-base conversion via integer math. For base2 and other power-of-2 bases, direct bit manipulation (like Go's base2.go) would be significantly faster. Consider:

• base2: Use bin() / int(s, 2) directly (matching Go's strconv.ParseInt(s, 2, 0))
• base16: Use binascii.hexlify / bytes.fromhex (already done for encode, check decode)
• base32/64: Use stdlib base64.b32encode / base64.b64encode with appropriate alphabets
• base36: Use an optimised library like base36 or custom implementation
• base58: Use base58 PyPI package (Bitcoin-optimised)

---

Appendix – Encoding Implementation Details

A.1 Base32 Case Sensitivity

Variant	Go decode	Python decode
base32 ('b')	Case-insensitive (NewEncodingCI)	⚠️ Case-sensitive (uses digits.index())
base32upper ('B')	Case-insensitive (NewEncodingCI)	⚠️ Case-sensitive
base32pad ('c')	Case-insensitive	⚠️ Case-sensitive
base32hex ('v')	Case-insensitive	⚠️ Case-sensitive

Potential bug: Python's base32 variants may fail to decode input that doesn't exactly match the case of the defined alphabet. This should be verified and fixed in Phase 2.

A.2 Base64 Implementation Differences

Aspect	Go	Python
base64 (no pad)	base64.RawStdEncoding (stdlib)	Custom Base64StringConverter with bit manipulation
base64pad	base64.StdEncoding (stdlib)	Custom Base64StringConverter with padding logic
base64url (no pad)	base64.RawURLEncoding (stdlib)	Custom Base64StringConverter
base64urlpad	base64.URLEncoding (stdlib)	Custom Base64StringConverter

Go uses the standard library's battle-tested base64 implementations. Python uses a custom bit-manipulation approach. Both should produce identical output, but the Python implementation should be verified against the Go output for all edge cases.

A.3 Base58 Libraries

Aspect	Go	Python
Library	mr-tron/base58	python-baseconv (generic BaseConverter)
BTC alphabet	b58.BTCAlphabet	Custom string in ENCODINGS
Flickr alphabet	b58.FlickrAlphabet	Custom string in ENCODINGS
Leading zero handling	Native optimised	Integer-based (may lose leading zeros for some inputs)

Risk: The generic BaseStringConverter converts bytes → int → base-N string. This approach can lose leading zero bytes (\x00) in edge cases. Go's mr-tron/base58 preserves leading zeros correctly. This should be verified with test vectors that include leading-zero data.

A.4 Dependency Comparison

Dependency	Go	Python	Purpose
base58	mr-tron/base58	python-baseconv	Base58 encoding
base32	multiformats/go-base32	Custom (Base32StringConverter)	Base32 encoding
base36	multiformats/go-base36	python-baseconv	Base36 encoding
base64	stdlib encoding/base64	Custom (Base64StringConverter)	Base64 encoding
bytes helpers	—	morphys	str↔bytes conversion
Python 2/3 compat	—	six (unnecessary for 3.10+)	Legacy compat

A.5 Base8 and Base10 — Python-Exclusive

Python implements base8 and base10 using the generic BaseStringConverter. Go defines the constants ('7' for base8, '9' for base10) but does not implement them — they are absent from EncodingToStr and the Encode/Decode switch statements. This means Python is the only reference implementation for these encodings.

Recommendation: Since these are part of the multibase spec but rarely used, document their Python-exclusive status clearly. Consider contributing test vectors to the official spec repository.

---

Summary Timeline

Phase	Focus	Effort	Key Deliverables
Phase 1	Correctness & Core API	1 week	EncoderByName, code-constant constructor, empty-string guard, emoji error with index
Phase 2	Encoder Parity & Enrichment	3–5 days	transcode(), case-insensitive base32, remove six, URL-safe base64 verification
Phase 3	Spec Compliance & Testing	1–2 weeks	Official spec tests, round-trip tests, fuzz testing, invalid-input rejection, base256emoji tests
Phase 4	CLI & Performance	1 week	multibase-conv CLI, benchmark suite, performance audit for base2/16/32/64

Total estimated effort: 4–5 weeks

Each phase is independently shippable. Phase 1 and 3 are the highest priority — Phase 1 fixes real API gaps, and Phase 3 ensures correctness against the official spec. Phase 2 and 4 are quality-of-life improvements.