The serialization format solves a similar problem to Protocol Buffers or JSON. If you haven't heard of either of those, then Mycelium might not solve a problem that you care about. Just after your quote the README mentions things like Products and Lists which both Protocol Buffers and JSON have support for in the form of Messages/Repeated and Objects/Lists respectively.

Mycelium has some interesting design choices compared to JSON and Protocol Buffers. Everything is built up from Bits, there is a Bit type which contains the values 0 and 1. Bytes are `Array[Bit, 8]` and Strings are `List[Byte]`. A 32 bit integer would be `Array[Bit, 32]`. There are also Sum (Coproduct) types, and cryptographic pointer types (called Refs in Mycelium).

Mycelium can be used to solve the same problems as those technologies. That's sort of table stakes for a serialization format. Mycelium additionally tackles the problem of sending procedures (called Lambdas in Mycelium) over the wire as well. That is a fairly simple feature to explain (get my procedure from here to there, it works with strings why not functions?), but it implies a significant amount of technology including a machine code specification and abstract machine model to execute it.

As for practical applications. Mycelium is suitable to be used as:

- A serialization format for storage and transfer.

- A VM with well controlled access to external resources for applications to run untrusted code.

- The VM can be a compiler target for programming languages. (Spore https://github.com/mycweb/mycelium/tree/master/spore is one such language)

- A format for data structures which need to be cryptographically signed. All Mycelium data structures are Merkle Trees.

- Large data structures which need to be efficiently synced. All Mycelium Values can be synced efficiently by traversing the cryptographic pointers and skipping values which are already available locally.

Very much agree. From the readme it sounds like there is a lot to this project, but I had a lot of trouble understanding why/where I would use this in the first place, or how it could improve on existing technologies.

It sounds to me like it's the same sort of thing as protobuf.

I'm not sure which paradoxes you are referring to. Type systems are used for a lot of things, in Mycelium a Type is an encoding strategy for it's Values. And just like I could explain the encoding strategy to you in text, the Type can be stored as bits representing that strategy, so a machine can read the Type and know how to decode Values using the strategy. Eventually this ends with predefined constants at the Type of a Type of a Value level, so there's a fixed point instead of an infinity.