{"id":13566448,"url":"https://github.com/udoprog/musli","last_synced_at":"2026-04-02T11:53:53.482Z","repository":{"id":39708139,"uuid":"482866484","full_name":"udoprog/musli","owner":"udoprog","description":"Müsli is a flexible and efficient serialization framework","archived":false,"fork":false,"pushed_at":"2026-03-24T07:56:56.000Z","size":71189,"stargazers_count":430,"open_issues_count":10,"forks_count":18,"subscribers_count":6,"default_branch":"main","last_synced_at":"2026-03-25T06:45:23.330Z","etag":null,"topics":["no-std","rust","serialization","zero-copy"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/udoprog.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE-APACHE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2022-04-18T13:57:25.000Z","updated_at":"2026-03-24T07:56:59.000Z","dependencies_parsed_at":"2024-03-16T22:41:07.506Z","dependency_job_id":"6aec6d87-8938-4d90-97ba-778c621cf978","html_url":"https://github.com/udoprog/musli","commit_stats":{"total_commits":178,"total_committers":1,"mean_commits":178.0,"dds":0.0,"last_synced_commit":"77610ef6aa7f33470900e0a98345e36069cb65a2"},"previous_names":[],"tags_count":166,"template":false,"template_full_name":null,"purl":"pkg:github/udoprog/musli","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/udoprog%2Fmusli","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/udoprog%2Fmusli/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/udoprog%2Fmusli/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/udoprog%2Fmusli/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/udoprog","download_url":"https://codeload.github.com/udoprog/musli/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/udoprog%2Fmusli/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31305895,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-02T09:48:21.550Z","status":"ssl_error","status_checked_at":"2026-04-02T09:48:19.196Z","response_time":89,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["no-std","rust","serialization","zero-copy"],"created_at":"2024-08-01T13:02:09.842Z","updated_at":"2026-04-02T11:53:53.474Z","avatar_url":"https://github.com/udoprog.png","language":"Rust","funding_links":[],"categories":["Rust"],"sub_categories":[],"readme":"# musli\n\n[\u003cimg alt=\"github\" src=\"https://img.shields.io/badge/github-udoprog/musli-8da0cb?style=for-the-badge\u0026logo=github\" height=\"20\"\u003e](https://github.com/udoprog/musli)\n[\u003cimg alt=\"crates.io\" src=\"https://img.shields.io/crates/v/musli.svg?style=for-the-badge\u0026color=fc8d62\u0026logo=rust\" height=\"20\"\u003e](https://crates.io/crates/musli)\n[\u003cimg alt=\"docs.rs\" src=\"https://img.shields.io/badge/docs.rs-musli-66c2a5?style=for-the-badge\u0026logoColor=white\u0026logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K\" height=\"20\"\u003e](https://docs.rs/musli)\n[\u003cimg alt=\"build status\" src=\"https://img.shields.io/github/actions/workflow/status/udoprog/musli/ci.yml?branch=main\u0026style=for-the-badge\" height=\"20\"\u003e](https://github.com/udoprog/musli/actions?query=branch%3Amain)\n\nExcellent performance, no compromises[^1]!\n\nMüsli is a flexible, fast, and generic binary serialization framework for\nRust, in the same vein as [`serde`].\n\nIt provides a set of [formats](#formats), each with its own well-documented\nset of features and tradeoffs. Every byte-oriented serialization method\nincluding escaped formats like [`musli::json`] has full `#[no_std]` support\nwith or without `alloc`. And a particularly neat component providing\nlow-level refreshingly simple [zero-copy serialization][zerocopy].\n\n[^1]: As in Müsli should be able to do everything you need and more.\n\n\u003cbr\u003e\n\n## Overview\n\n* See [`derives`] to learn how to implement [`Encode`] and [`Decode`].\n* See [`data_model`] to learn about the abstract data model of Müsli.\n* See [benchmarks] and [size comparisons] to learn about the performance of\n  this framework.\n* See [`tests`] to learn how this library is tested.\n* See [`musli::serde`] for seamless compatibility with [`serde`]. You might\n  also be interested to learn how [Müsli is different][different].\n\n[different]: #müsli-is-different-from-serde\n\n\u003cbr\u003e\n\n## Usage\n\nAdd the following to your `Cargo.toml` using the [format](#formats) you want\nto use:\n\n```toml\n[dependencies]\nmusli = { version = \"0.0.149\", features = [\"storage\"] }\n```\n\n\u003cbr\u003e\n\n## Design\n\nThe heavy lifting is done by the [`Encode`] and [`Decode`] derives which are\ndocumented in the [`derives`] module.\n\nMüsli operates based on the schema represented by the types which implement\nthese traits.\n\n```rust\nuse musli::{Encode, Decode};\n\n#[derive(Encode, Decode)]\nstruct Person {\n    /* .. fields .. */\n}\n```\n\n\u003e **Note** by default a field is identified by its *numerical index* which\n\u003e would change if they are re-ordered. Renaming fields and setting a default\n\u003e naming policy can be done by configuring the [`derives`].\n\nThe binary serialization formats provided aim to efficiently and accurately\nencode every type and data structure available in Rust. Each format comes\nwith [well-documented tradeoffs](#formats) and aims to be fully memory safe\nto use.\n\nInternally we use the terms \"encoding\", \"encode\", and \"decode\" because it's\ndistinct from [`serde`]'s use of \"serialization\", \"serialize\", and\n\"deserialize\" allowing for the clearer interoperability between the two\nlibraries. Encoding and decoding also has more of a \"binary serialization\"\nvibe, which more closely reflects the focus of this framework.\n\nMüsli is designed on similar principles as [`serde`]. Relying on Rust's\npowerful trait system to generate code which can largely be optimized away.\nThe end result should be very similar to handwritten, highly optimized code.\n\nAs an example of this, these two functions both produce the same assembly\n(built with `--release`):\n\n```rust\nconst OPTIONS: Options = options::new().fixed().native_byte_order().build();\nconst ENCODING: Encoding\u003cOPTIONS\u003e = Encoding::new().with_options();\n\n#[derive(Encode, Decode)]\n#[musli(packed)]\npub struct Storage {\n    left: u32,\n    right: u32,\n}\n\nfn with_musli(storage: \u0026Storage) -\u003e Result\u003c[u8; 8]\u003e {\n    let mut array = [0; 8];\n    ENCODING.encode(\u0026mut array[..], storage)?;\n    Ok(array)\n}\n\nfn without_musli(storage: \u0026Storage) -\u003e Result\u003c[u8; 8]\u003e {\n    let mut array = [0; 8];\n    array[..4].copy_from_slice(\u0026storage.left.to_ne_bytes());\n    array[4..].copy_from_slice(\u0026storage.right.to_ne_bytes());\n    Ok(array)\n}\n```\n\n\u003cbr\u003e\n\n## Müsli is different from [`serde`]\n\n**Müsli's data model does not speak Rust**. There are no\n`serialize_struct_variant` methods which provides metadata about the type\nbeing serialized. The [`Encoder`] and [`Decoder`] traits are agnostic on\nthis. Compatibility with Rust types is entirely handled using the [`Encode`]\nand [`Decode`] derives in combination with [modes](#Modes).\n\n**We use GATs** to provide easier to use abstractions. GATs were not\navailable when serde was designed.\n\n**Everything is a [`Decoder`] or [`Encoder`]**. Field names are therefore\nnot limited to be strings or indexes, but can be named to [arbitrary\ntypes][musli-name-type] if needed.\n\n**Visitor are only used when needed**. `serde` [completely uses visitors]\nwhen deserializing and the corresponding method is treated as a \"hint\" to\nthe underlying format. The deserializer is then free to call any method on\nthe visitor depending on what the underlying format actually contains. In\nMüsli, we swap this around. If the caller wants to decode an arbitrary type\nit calls [`decode_any`]. The format can then either signal the appropriate\nunderlying type or call [`Visitor::visit_unknown`] telling the implementer\nthat it does not have access to type information.\n\n**We've invented [*moded encoding*](#Modes)** allowing the same Rust types\nto be encoded in many different ways with much greater control over how\nthings encoded. By default we include the [`Binary`] and [`Text`] modes\nproviding sensible defaults for binary and text-based formats.\n\n**Müsli fully supports [no-std and no-alloc]** from the ground up without\ncompromising on features using safe and efficient [scoped allocations].\n\n**We support [detailed tracing]** when decoding for much improved\ndiagnostics of *where* something went wrong.\n\n\u003cbr\u003e\n\n## Formats\n\nFormats are currently distinguished by supporting various degrees of\n*upgrade stability*. A fully upgrade stable encoding format must tolerate\nthat one model can add fields that an older version of the model should be\ncapable of ignoring.\n\nPartial upgrade stability can still be useful as is the case of the\n[`musli::storage`] format below, because reading from storage only requires\ndecoding to be upgrade stable. So if correctly managed with\n`#[musli(default)]` this will never result in any readers seeing unknown\nfields.\n\nThe available formats and their capabilities are:\n\n| | `reorder` | `missing` | `unknown` | `self` |\n|-|-|-|-|-|\n| [`musli::packed`] (with `#[musli(packed)]`) | ✗ | ✗ | ✗ | ✗ |\n| [`musli::storage`]                          | ✔ | ✔ | ✗ | ✗ |\n| [`musli::wire`]                             | ✔ | ✔ | ✔ | ✗ |\n| [`musli::descriptive`]                      | ✔ | ✔ | ✔ | ✔ |\n| [`musli::json`] [^json]                     | ✔ | ✔ | ✔ | ✔ |\n\n`reorder` determines whether fields must occur in exactly the order in which\nthey are specified in their type. Reordering fields in such a type would\ncause unknown but safe behavior of some kind. This is only suitable for\ncommunication where the data models of each client are strictly\nsynchronized.\n\n`missing` determines if reading can handle missing fields through something\nlike `Option\u003cT\u003e`. This is suitable for on-disk storage, because it means\nthat new optional fields can be added as the schema evolves.\n\n`unknown` determines if the format can skip over unknown fields. This is\nsuitable for network communication. At this point you've reached [*upgrade\nstability*](#upgrade-stability). Some level of introspection is possible\nhere, because the serialized format must contain enough information about\nfields to know what to skip which usually allows for reasoning about basic\ntypes.\n\n`self` determines if the format is self-descriptive. Allowing the structure\nof the data to be fully reconstructed from its serialized state. These\nformats do not require models to decode and can be converted to and from\ndynamic containers such as [`musli::value`] for introspection. Such formats\nalso allows for type-coercions to be performed, so that a signed number can\nbe correctly read as an unsigned number if it fits in the destination type.\n\nFor every feature you drop, the format becomes more compact and efficient.\n[`musli::storage`] using `#[musli(packed)]` for example is roughly as compact\nas [`bincode`] while [`musli::wire`] is comparable in size to something like\n[`protobuf`]. All formats are primarily byte-oriented, but some might\nperform [bit packing] if the benefits are obvious.\n\n[^json]: This is strictly not a binary serialization, but it was implemented\nas a litmus test to ensure that Müsli has the necessary framework features\nto support it. Luckily, the implementation is also quite good!\n\n\u003cbr\u003e\n\n## Upgrade stability\n\nThe following is an example of *full upgrade stability* using\n[`musli::wire`]. `Version1` can be decoded from an instance of `Version2`\nbecause it understands how to skip fields which are part of `Version2`.\nWe're also explicitly adding `#[musli(name = ..)]` to the fields to ensure\nthat they don't change in case they are re-ordered.\n\n```rust\nuse musli::{Encode, Decode};\n\n#[derive(Debug, PartialEq, Encode, Decode)]\nstruct Version1 {\n    #[musli(Binary, name = 0)]\n    name: String,\n}\n\n#[derive(Debug, PartialEq, Encode, Decode)]\nstruct Version2 {\n    #[musli(Binary, name = 0)]\n    name: String,\n    #[musli(Binary, name = 1)]\n    #[musli(default)]\n    age: Option\u003cu32\u003e,\n}\n\nlet version2 = musli::wire::to_vec(\u0026Version2 {\n    name: String::from(\"Aristotle\"),\n    age: Some(61),\n})?;\n\nlet version1: Version1 = musli::wire::decode(version2.as_slice())?;\n```\n\nThe following is an example of *partial upgrade stability* using\n[`musli::storage`] on the same data models. Note how `Version2` can be\ndecoded from `Version1` but *not* the other way around making it suitable\nfor on-disk storage where the schema can evolve from older to newer\nversions.\n\n```rust\nlet version2 = musli::storage::to_vec(\u0026Version2 {\n    name: String::from(\"Aristotle\"),\n    age: Some(61),\n})?;\n\nassert!(musli::storage::decode::\u003c_, Version1\u003e(version2.as_slice()).is_err());\n\nlet version1 = musli::storage::to_vec(\u0026Version1 {\n    name: String::from(\"Aristotle\"),\n})?;\n\nlet version2: Version2 = musli::storage::decode(version1.as_slice())?;\n```\n\n\u003cbr\u003e\n\n## Modes\n\nIn Müsli in contrast to [`serde`] the same model can be serialized in\ndifferent ways. Instead of requiring the use of distinct models we support\nimplementing different *modes* for a single model.\n\nA mode is a type parameter, which allows for different attributes to apply\ndepending on which mode an encoder is configured to use. A mode can apply to\n*any* musli attributes giving you a lot of flexibility.\n\nIf a mode is not specified, an implementation will apply to all modes (`M`),\nif at least one mode is specified it will be implemented for all modes which\nare present in a model and [`Binary`] and [`Text`]. This way, an encoding\nwhich uses [`Binary`] or [`Text`] which are the default modes should always\nwork.\n\nFor more information on how to configure modes, see [`derives`].\n\nBelow is a simple example of how we can use two modes to provide two\ncompletely different formats using a single struct:\n\n```rust\nuse musli::{Decode, Encode};\nuse musli::json::Encoding;\n\nenum Alt {}\n\n#[derive(Decode, Encode)]\n#[musli(Text, name_all = \"name\")]\n#[musli(mode = Alt, packed)]\nstruct Word\u003c'a\u003e {\n    text: \u0026'a str,\n    teineigo: bool,\n}\n\nconst TEXT: Encoding = Encoding::new();\nconst ALT: Encoding\u003cAlt\u003e = Encoding::new().with_mode();\n\nlet word = Word {\n    text: \"あります\",\n    teineigo: true,\n};\n\nlet out = TEXT.to_string(\u0026word)?;\nassert_eq!(out, r#\"{\"text\":\"あります\",\"teineigo\":true}\"#);\n\nlet out = ALT.to_string(\u0026word)?;\nassert_eq!(out, r#\"[\"あります\",true]\"#);\n```\n\n\u003cbr\u003e\n\n## Going very fast\n\nWith the previous sections it should be apparent that speed is primarily a\ngame of tradeoffs. If we make every tradeoff in favor of speed Müsli is\ndesigned to be the fastest framework out there.\n\nThe tradeoffs we will be showcasing to achieve speed here are:\n\n* *Pre-allocate serialization space*. This avoids all allocations during\n  serialization. The tradeoff is that if the data we are serializing\n  contains dynamically sized information which goes beyond the pre-allocated\n  space, we will error.\n* *Use fixed-sized integers and floats*. We use more space, but the cost of\n  serializing numerical fields essentially boils down to copying them.\n* *Use a native byte order*. With this we avoid any byte-swapping\n  operations. But our data becomes less portable.\n* *Use a packed format*. This doesn't allow for any upgrades, but we avoid\n  paying the overhead of serializing field identifiers.\n* *Use the [`Slice` allocator]*. This avoids all heap allocations using the\n  global allocator. While the global allocator is quite efficient and\n  normally shouldn't be avoided, the slice allocator is a fixed-slab\n  allocator. The tradeoff here is that we will error in case we run out of\n  memory, but we only need to use the allocator if the types being\n  serialized (or the format) demands it.\n* *Disable error handling*. Code generation will be able to remove\n  everything related to error handling, like allocations. To do this we can\n  make use of the [default context] without configuring it for tracing. If\n  an error happens, we are only informed of that fact through a zero-sized\n  marker type.\n\nWe achieve this through the following methods:\n\n```rust\nuse musli::alloc::{Allocator, Global};\nuse musli::context::{self, ErrorMarker as Error};\nuse musli::options::{self, Float, Integer, Width, Options};\nuse musli::storage::Encoding;\nuse musli::{Decode, Encode};\nuse musli::alloc::Slice;\n\nenum Packed {}\n\nconst OPTIONS: Options = options::new().fixed().native_byte_order().build();\nconst ENCODING: Encoding\u003cOPTIONS, Packed\u003e = Encoding::new().with_options().with_mode();\n\n#[inline]\npub fn encode\u003c'buf, T, A\u003e(buf: \u0026'buf mut [u8], value: \u0026T, alloc: A) -\u003e Result\u003c\u0026'buf [u8], Error\u003e\nwhere\n    T: Encode\u003cPacked\u003e,\n    A: Allocator,\n{\n    let cx = context::new_in(alloc);\n    let w = ENCODING.to_slice_with(\u0026cx, \u0026mut buf[..], value)?;\n    Ok(\u0026buf[..w])\n}\n\n#[inline]\npub fn decode\u003c'buf, T, A\u003e(buf: \u0026'buf [u8], alloc: A) -\u003e Result\u003cT, Error\u003e\nwhere\n    T: Decode\u003c'buf, Packed, A\u003e,\n    A: Allocator,\n{\n    let cx = context::new_in(alloc);\n    ENCODING.from_slice_with(\u0026cx, buf)\n}\n```\n\nWe also need some cooperation from the types being serialized since they\nneed to use the `Packed` mode we defined just above:\n\n```rust\nuse musli::{Encode, Decode};\n\n#[derive(Encode, Decode)]\n#[musli(mode = Packed, packed)]\nstruct Person {\n    name: String,\n    age: u32,\n}\n```\n\nUsing the framework above also needs a bit of prep, namely the slice\nallocator need to be initialized:\n\n```rust\nuse musli::alloc::{ArrayBuffer, Slice};\n\nlet mut buf = ArrayBuffer::new();\nlet alloc = Slice::new(\u0026mut buf);\n```\n\nThat's it! You are now using Müsli in the fastest possible mode. Feel free\nto use it to \"beat\" any benchmarks. In fact, the `musli_packed` mode in our\ninternal [benchmarks] beat pretty much every framework with these methods.\n\n\u003e My hope is that this should illustrate why you shouldn't blindly trust\n\u003e benchmarks. Sometimes code is not fully optimized, but most of the time\n\u003e there is a tradeoff. If a benchmark doesn't tell you what tradeoffs are\n\u003e being made, don't just naively trust a number.\n\n\u003cbr\u003e\n\n## Unsafety\n\nThis is a non-exhaustive list of unsafe use in this crate, and why they are\nused:\n\n* A `mem::transmute` in `Tag::kind`. Which guarantees that converting into\n  the `Kind` enum which is `#[repr(u8)]` is as efficient as possible.\n\n* A largely unsafe `SliceReader` which provides more efficient reading than\n  the default `Reader` impl for `\u0026[u8]` does. Since it can perform most of\n  the necessary comparisons directly on the pointers.\n\n* Some unsafety related to UTF-8 handling in `musli::json`, because we check\n  UTF-8 validity internally ourselves (like `serde_json`).\n\n* `FixedBytes\u003cN\u003e`, which is a stack-based container that can operate over\n  uninitialized data. Its implementation is largely unsafe. With it\n  stack-based serialization can be performed which is useful in no-std\n  environments.\n\n* Some `unsafe` is used for owned `String` decoding in all binary formats to\n  support faster string processing through [`simdutf8`]. Disabling the\n  `simdutf8` feature (enabled by default) removes the use of this unsafe.\n\nTo ensure this library is correctly implemented with regards to memory\nsafety, extensive testing and fuzzing is performed using `miri`. See\n[`tests`] for more information.\n\n\u003cbr\u003e\n\n[`Binary`]: \u003chttps://docs.rs/musli/latest/musli/mode/enum.Binary.html\u003e\n[`bincode`]: \u003chttps://docs.rs/bincode\u003e\n[`data_model`]: \u003chttps://docs.rs/musli/latest/musli/_help/data_model/\u003e\n[`decode_any`]: https://docs.rs/musli/latest/musli/trait.Decoder.html#method.decode_any\n[`Decode`]: \u003chttps://docs.rs/musli/latest/musli/de/trait.Decode.html\u003e\n[`Decoder`]: \u003chttps://docs.rs/musli/latest/musli/trait.Decoder.html\u003e\n[`derives`]: \u003chttps://docs.rs/musli/latest/musli/_help/derives/\u003e\n[`Encode`]: \u003chttps://docs.rs/musli/latest/musli/en/trait.Encode.html\u003e\n[`Encoder`]: \u003chttps://docs.rs/musli/latest/musli/trait.Encoder.html\u003e\n[`musli::descriptive`]: \u003chttps://docs.rs/musli/latest/musli/descriptive/\u003e\n[`musli::json`]: \u003chttps://docs.rs/musli/latest/musli/json/\u003e\n[`musli::packed`]: \u003chttps://docs.rs/musli/latest/musli/packed/\u003e\n[`musli::serde`]: \u003chttps://docs.rs/musli/latest/musli/serde/\u003e\n[`musli::storage`]: \u003chttps://docs.rs/musli/latest/musli/storage/\u003e\n[`musli::value`]: \u003chttps://docs.rs/musli/latest/musli/value/\u003e\n[`musli::wire`]: \u003chttps://docs.rs/musli/latest/musli/wire/\u003e\n[`protobuf`]: \u003chttps://developers.google.com/protocol-buffers\u003e\n[`serde`]: \u003chttps://serde.rs\u003e\n[`simdutf8`]: \u003chttps://docs.rs/simdutf8\u003e\n[`Slice` allocator]: \u003chttps://docs.rs/musli/latest/musli/alloc/struct.Slice.html\u003e\n[`tests`]: \u003chttps://github.com/udoprog/musli/tree/main/tests\u003e\n[`Text`]: \u003chttps://docs.rs/musli/latest/musli/mode/enum.Text.html\u003e\n[`Visitor::visit_unknown`]: https://docs.rs/musli/latest/musli/de/trait.Visitor.html#method.visit_unknown\n[benchmarks]: \u003chttps://udoprog.github.io/musli/benchmarks/\u003e\n[bit packing]: \u003chttps://github.com/udoprog/musli/blob/main/crates/musli/src/descriptive/tag.rs\u003e\n[completely uses visitors]: https://docs.rs/serde/latest/serde/trait.Deserializer.html#tymethod.deserialize_u32\n[default context]: \u003chttps://docs.rs/musli/latest/musli/context/new_in.html\u003e\n[detailed tracing]: \u003chttps://udoprog.github.io/rust/2023-05-22/abductive-diagnostics-for-musli.html\u003e\n[musli-name-type]: \u003chttps://docs.rs/musli/latest/musli/_help/derives/#muslinametype--type\u003e\n[no-std and no-alloc]: \u003chttps://github.com/udoprog/musli/blob/main/no-std/examples/\u003e\n[scoped allocations]: \u003chttps://docs.rs/musli/latest/musli/trait.Context.html#tymethod.alloc\u003e\n[size comparisons]: \u003chttps://udoprog.github.io/musli/benchmarks/#size-comparisons\u003e\n[zerocopy]: \u003chttps://docs.rs/musli-zerocopy\u003e\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fudoprog%2Fmusli","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fudoprog%2Fmusli","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fudoprog%2Fmusli/lists"}