BD103's Blog

Rust Hashing Cheat Sheet

2025-11-10T00:00:00+00:00

Hashing is the process of transforming arbitrary data into a fixed-size number. Several useful programming concepts arise out of hash codes:</p>

Storing passwords</li> </ul>

Recently I tried writing a hash set from scratch in Rust</a> for educational purposes, but was awfully confused by the collection of traits and types provided by std::hash</code></a>. In this post I hope to share some common patterns related to hashing in Rust, while explaining std::hash</code> as I go.</p>

Hashing a Single Value

</a>
</h2>
Hashing a value is as simple as creating a Hasher</code>, calling value.hash(&mut hasher)</code>, and then calling hasher.finish()</code>.</p>
use</span> std</span>::</span>hash</span>::</span>{</span>DefaultHasher</span>,</span> Hash</span>,</span> Hasher</span>}</span>;</span></span>
</span>
let</span> mut</span> hasher</span> =</span> DefaultHasher</span>::</span>new</span>(</span>)</span>;</span></span>
"</span>Hello, world!</span>"</span>.</span>hash</span>(</span>&</span>mut</span> hasher</span>)</span>;</span></span>
let</span> hash</span>:</span> u64</span> =</span> hasher</span>.</span>finish</span>(</span>)</span>;</span></span>
</span>
println!</span>(</span>"</span>Hash: </span>{</span>hash</span>}</span>"</span>)</span>;</span> //</span> Hash: 7092736762612737980</span></span></code></pre>Hashing Several Values into One Code</a>
</h2>
You can call value.hash(&mut hasher)</code> several times to create a hash code composed of multiple data sources. This is useful when hashing structs or arrays.</p>
use</span> std</span>::</span>hash</span>::</span>{</span>DefaultHasher</span>,</span> Hash</span>,</span> Hasher</span>}</span>;</span></span>
</span>
let</span> mut</span> hasher</span> =</span> DefaultHasher</span>::</span>new</span>(</span>)</span>;</span></span>
</span>
"</span>Hello</span>"</span>.</span>hash</span>(</span>&</span>mut</span> hasher</span>)</span>;</span></span>
13</span>u64</span>.</span>hash</span>(</span>&</span>mut</span> hasher</span>)</span>;</span></span>
false</span>.</span>hash</span>(</span>&</span>mut</span> hasher</span>)</span>;</span></span>
</span>
let</span> hash</span>:</span> u64</span> =</span> hasher</span>.</span>finish</span>(</span>)</span>;</span></span>
</span>
println!</span>(</span>"</span>Hash: </span>{</span>hash</span>}</span>"</span>)</span>;</span> //</span> Hash: 3402450879032501501</span></span></code></pre>Hash</code>, Hasher</code>, and DefaultHasher</code></a>
</h2>

Hash</code></a>: a type that can be hashed (str</code>, u64</code>, bool</code>, etc.)</li>
Hasher</code></a>: a hashing algorithm (DefaultHasher</code>, 3rd-party implementations)</li>
DefaultHasher</code></a>: Rust's default hashing algorithm1</a></sup></li>
</ul>
Hasher</code>s are never re-used to make several hash codes. If you want to compute a new hash code, you discard the current Hasher</code> and create a new one.</p>
Hashing with a Random Seed</a>
</h2>
To make a hash resilient to hash flooding</a>, you can create a Hasher</code> with a random seed using RandomState</code>.</p>
use</span> std</span>::</span>hash</span>::</span>{</span>BuildHasher</span>,</span> Hash</span>,</span> Hasher</span>,</span> RandomState</span>}</span>;</span></span>
</span>
let</span> state</span> =</span> RandomState</span>::</span>new</span>(</span>)</span>;</span></span>
</span>
let</span> mut</span> hasher</span> =</span> state</span>.</span>build_hasher</span>(</span>)</span>;</span></span>
"</span>Hello, world!</span>"</span>.</span>hash</span>(</span>&</span>mut</span> hasher</span>)</span>;</span></span>
let</span> hash</span> =</span> hasher</span>.</span>finish</span>(</span>)</span>;</span></span>
</span>
println!</span>(</span>"</span>Hash: </span>{</span>hash</span>}</span>"</span>)</span>;</span> //</span> Hash: 1905042730872565693</span></span></code></pre>
There's also a shorthand for this pattern using BuildHasher::hash_one()</code></a>.</p>
use</span> std</span>::</span>hash</span>::</span>{</span>BuildHasher</span>,</span> RandomState</span>}</span>;</span></span>
</span>
let</span> state</span> =</span> RandomState</span>::</span>new</span>(</span>)</span>;</span></span>
</span>
let</span> hash</span> =</span> state</span>.</span>hash_one</span>(</span>"</span>Hello, world!</span>"</span>)</span>;</span></span>
</span>
println!</span>(</span>"</span>Hash: </span>{</span>hash</span>}</span>"</span>)</span>;</span> //</span> Hash: 11506452463443521132</span></span></code></pre>
Note how the hash codes are different from the two examples, even though they're both hashing "Hello, world!"</code>, because RandomState::new()</code> creates a new random seed each time it is called.</p>
BuildHasher</code> and RandomSeed</code></a>
</h2>

BuildHasher</code></a>: a type that can create a new Hasher</code> with a seed</li>
RandomState</code></a>: generates a random seed when constructed, then builds Hasher</code>s using that seed</li>
</ul>
If you want to hash two separate values and compare them for equality, you would typically create one RandomState</code> then use it to build two DefaultHasher</code>s with the same seed.2</a></sup></p>
Deriving Hash</code></a>
</h2>
The easiest way to make a custom type hashable is by deriving Hash</code>.</p>
use</span> std</span>::</span>hash</span>::</span>{</span>DefaultHasher</span>,</span> Hash</span>,</span> Hasher</span>}</span>;</span></span>
</span>
#</span>[</span>derive</span>(</span>Hash</span>)</span>]</span></span>
struct</span> Foo</span> {</span></span>
    a</span>:</span> &</span>'</span>static</span> str</span>,</span></span>
    b</span>:</span> u64</span>,</span></span>
    c</span>:</span> bool</span>,</span></span>
}</span></span>
</span>
let</span> mut</span> hasher</span> =</span> DefaultHasher</span>::</span>new</span>(</span>)</span>;</span></span>
</span>
Foo</span> {</span> a</span>:</span> "</span>Hello</span>"</span>,</span> b</span>:</span> 13</span>,</span> c</span>:</span> false</span> }</span>.</span>hash</span>(</span>&</span>mut</span> hasher</span>)</span>;</span></span>
</span>
let</span> hash</span>:</span> u64</span> =</span> hasher</span>.</span>finish</span>(</span>)</span>;</span></span>
</span>
println!</span>(</span>"</span>Hash: </span>{</span>hash</span>}</span>"</span>)</span>;</span> //</span> Hash: 3402450879032501501</span></span></code></pre>Implementing Hash</code> Manually</a>
</h2>
If you look closely, you'll notice that the hash codes from Hashing Several Values into One Code</a> and Deriving Hash</code></a> are equal! This is because they're hashing the same data in the same order with the same seed. To prove this, we can expand the Hash</code> derivation:</p>
use</span> std</span>::</span>hash</span>::</span>{</span>Hash</span>,</span> Hasher</span>}</span>;</span></span>
</span>
struct</span> Foo</span> {</span></span>
    a</span>:</span> &</span>'</span>static</span> str</span>,</span></span>
    b</span>:</span> u64</span>,</span></span>
    c</span>:</span> bool</span>,</span></span>
}</span></span>
</span>
impl</span> Hash</span> for</span> Foo</span> {</span></span>
    fn</span> hash</span><</span>H</span>:</span> Hasher</span>></span>(</span>&</span>self</span>,</span> state</span>:</span> &</span>mut</span> H</span>)</span> {</span></span>
        self</span>.</span>a</span>.</span>hash</span>(</span>state</span>)</span>;</span></span>
        self</span>.</span>b</span>.</span>hash</span>(</span>state</span>)</span>;</span></span>
        self</span>.</span>c</span>.</span>hash</span>(</span>state</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>Conclusion</a>
</h2>
I hope these examples help you wrap your head around Rust's hashing support! While I didn't cover it in this article, you may be also interested in Hasher</code></a>'s methods and how primitives like bool</code></a>, char</code></a>, and tuples</a> implement Hash</code>. You may also enjoy looking at rustc-hash</code></a> (previous fxhash</code>), fnv</code></a>, sha2</code></a>, and blake2</code></a>.</p>
Happy hacking!</p>



In Rust 1.91.0 the default hashing algorithm is SipHash 1-3</a>, but this is an internal detail that may change in the future. ↩</a></p>
</li>

Technically, you could just create the two hashers by calling DefaultHasher::new()</code>, which initializes them with a seed of 0. This is vulnerable to hash flooding</a> attacks, however, so I don't recommend it! ↩</a></p>
</li>
</ol>
</section>



Bevy's 5th Birthday: Year of the Linter
2025-09-09T00:00:00+00:00
Bevy</a> is an open-source game engine built in Rust. On August 10th, 2025, the project lead Cart celebrated Bevy's 5th birthday with a blog post</a>, and I wanted to do the same!</p>
Hi, I'm BD103</a>
</h2>
For those uninitiated, I'm BD103! I'm a programmer who's been working on Bevy for a little under 2 years, at this point. Last year</a> I talked about how I got involved with Bevy and how I found my place working on the CI infrastructure. This year, you’re in for a treat, as I took my work in a fun, new direction!</p>
Nerd Snipe of the Year</a>
</h2>
In late August of 2024, one of the maintainers, Alice</a>, was helping a contributor find larger, independent projects to work on related to Bevy. One of the ideas she mentioned was a Bevy CLI, a command-line tool that would help users setup and manage their Bevy projects.</p>
Now the idea of a Bevy CLI has been around for quite some time, with an issue opened about it in late 2020</a>. When I saw Alice mention a Bevy CLI, I did some digging and found that specific issue. In the issue description it listed several possible commands, but one of which really caught my attention:</p>

  
  
bevy lint</code> - possibly checks the project for best practices?</li>
</ul>
</div>
  
  
    — bevy cli #436</a></p>

  </div>
  
</blockquote>
So...</p>

    
    
    I was thoroughly nerd-sniped, via</a></p>
</figcaption>
    
</figure>
Thankfully I Did Not Get Run Over by a Truck1</a></sup></a>
</h2>
The concept of a Bevy linter led me down a looooong</em> rabbit hole, but I hit the bottom with a skip in my step and a plan of action in my head. I joined the newly-created Bevy CLI working group</a> and wrote a design document</a> for the linter based on the architecture of Clippy</a>. Once I got a thumbs-up 👍 from the working group, I got to work contributing my design to the new TheBevyFlock/bevy_cli</code></a> repository.</p>
From late August to mid-November, I and a few others worked on the linter until we got it to a place where it could be released as v0.1.0</a>. That release came with 6 lints, live documentation, and lots of infrastructure set up for future releases.</p>
Briefly Being Famous</a>
</h2>
4 days after releasing v0.1.0, I went on the 7th Bevy Meetup livestream</a> and presented a talk on the linter. In my talk I went into the architecture behind the linter, and gave examples building up a new linter from scratch using the same method. You can see the demo code and slides here</a>, if you're curious. It was great working with the host Stephan</a>, and I really enjoyed presenting alongside speakers Zac</a> and Koe</a>!</p>
The Next 3 Releases</a>
</h2>
After the first release, I and a few others in the working group published v0.2.0 in March of 2025</a>, v0.3.0 in April of 2025</a>, and v0.4.0 in August of 2025</a>. While these releases did add several new lints, much of my personal work focused on other aspects of the linter:</p>

Upgrading to support new versions of Bevy and Rust</li>
Fixing and improving existing lints, renaming and merging them when it made sense</li>
Writing and refining our external and internal documentation</li>
Adding support for configuring lints in Cargo.toml</code></li>
Assisting with writing RFC 3808</a> in order to make it easier to configure lints within code</li>
Improving support for running the linter in Github Actions</li>
Adding the ability to auto-fix warnings with the --fix</code> flag</li>
</ul>
This has been a trend in my work for a while. While I do enjoy writing new features, I tend to spend a lot more time looking over existing code and trying my best to improve it. I would like to write more lints, as I'm not satisfied with our current selection</a>, but that's a project for a later date.</p>
Thank You</a>
</h2>
The Bevy community is such a kind and welcoming place, and I'd be remiss to not mention my co-maintainers who I've worked with in the Bevy CLI working group for the past year!</p>
Tim</a></a>
</h3>
Tim, you are the driving force behind the CLI since its earliest days in the working group. Many of the largest features, including easy web support</a> and the upcoming getrandom</code> fix</a>, were implemented by of you. You've truly left your mark on the Bevy community2</a></sup>, and it's been wonderful working alongside you!</p>
David</a></a>
</h3>
David, you were the first outside contributor to continuously</em> work on the CLI and linter. Although we've had several one-off contributions from others, you both started and stuck with the project. Unlike Tim who specializes in the CLI and myself who specializes in the linter, you've worked on and improved both. You're knowledge of both tools has made you super valuable in the review process, and it's been really fun getting to know you!</p>
In Conclusion</a>
</h2>
I'm truly grateful to have been given the opportunity to work on Bevy and within its ecosystem. While the project itself is cool3</a></sup>, the people are why I stayed</strong>.</p>
If you use Bevy and haven't given it a shot yet, I'd really appreciate it if you tried out the CLI and linter for yourself</a>! They're both unofficial right now, but we're working on upstreaming them into an official product in the near future.</p>
If you'd like to support my work, you can do so indirectly by donating to the Bevy Foundation</a> or by purchasing some sweet official merch</a>. I'm not in a position to take donations myself, but the people working for the foundation</a> are wonderful and highly deserving of any support you can give them.</p>
If you'd like to see more posts by community members on Bevy's 5th Birthday, I've enjoyed reading through these:</p>

Cart's Perspective</a></li>
Charlotte's Perspective</a></li>
Rin's Perspective</a></li>
Jasmine's Perspective</a></li>
</ul>
There are also several more in the community submissions issue on Github</a> that I highly recommend checking out!</p>
That's all from me for now! If you'd like to chat, I'm @bd103 on Discord</a> and @bd103@hachyderm.io</a> on Mastodon. Until next time,</p>
- BD103</p>



But any future work I may have done on the engine itself did get run over by the said metaphorical truck. I was officially nerd-sniped. ↩</a></p>
</li>

This is especially true for the jammers who participated in the 6th Bevy Game jam</a>. The CLI combined with bevy_new_2d</code></a> drastically</em> decreased the difficulty of making a new Bevy game from scratch. ↩</a></p>
</li>

Game engines are really fun to build, especially when you want to make one that's both efficient and ergonomic! ↩</a></p>
</li>
</ol>
</section>


Be Careful Zero-Copying Strings with serde
2025-09-01T00:00:00+00:00
When deserializing a string using serde</code></a>, it is possible to use a borrowed &str</code></a> instead of an owned String</code></a>:</p>
use</span> serde</span>::</span>Deserialize</span>;</span></span>
use</span> serde_json</span>;</span></span>
</span>
#</span>[</span>derive</span>(</span>Deserialize</span>)</span>]</span></span>
struct</span> Foo</span><</span>'</span>a</span>></span> {</span></span>
    //</span> This string is borrowed.</span></span>
    text</span>:</span> &</span>'</span>a</span> str</span>,</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> json</span> =</span> r</span>#</span>"</span>{ "text": "Hello, world!" }</span>"</span>#</span>;</span></span>
</span>
    let</span> foo</span>:</span> Foo</span> =</span> serde_json</span>::</span>from_str</span>(</span>json</span>)</span>.</span>unwrap</span>(</span>)</span>;</span></span>
</span>
    println!</span>(</span>"</span>{</span>}</span>"</span>,</span> foo</span>.</span>text</span>)</span>;</span> //</span> Hello, world!</span></span>
}</span></span></code></pre>
The borrowed string is a reference to a portion of the original serialized data. In this case, foo.text</code> refers to a slice of the json</code> variable that contains the text Hello, world!</code>.</p>
This process is called zero-copy deserialization, and can be more efficient than allocating a new String</code> and copying the data to it. Be warned, however; some strings cannot be deserialized into &str</code>, and must be deserialized into a String</code> instead</strong>.</p>
The specific case where I found this out was when I was deserializing text with backslashes in it:</p>
let</span> json</span> =</span> r</span>#</span>"</span>{ "text": "Go to C:\\Users\\bd\\Desktop" }</span>"</span>#</span>;</span></span>
</span>
let</span> foo</span>:</span> Foo</span> =</span> serde_json</span>::</span>from_str</span>(</span>json</span>)</span>.</span>unwrap</span>(</span>)</span>;</span></span>
</span>
println!</span>(</span>"</span>{</span>}</span>"</span>,</span> foo</span>.</span>text</span>)</span>;</span></span></code></pre>
Instead of printing Go to C:\Users\bd\Desktop</code> as I expected, it instead panicked!</p>
thread 'main' panicked at src/main.rs:12:47:</span></span>
called `Result::unwrap()` on an `Err` value: Error("invalid type: string \"Go to C:\\\\Users\\\\bd\\\\Desktop\", expected a borrowed string", line: 1, column: 34)</span></span></code></pre>
When deserializing the text, serde_json</code> needs to convert Go to C:\\Users\\bd\\Desktop</code> to Go to C:\Users\bd\Desktop</code>. The only way it can do that is by allocating a new string</em>. serde_json</code> can't do that here, however, because we told it not to by using zero-copy deserialization!</p>
In order to fix this, you need to replace the borrowed &str</code> with an owned String</code>. It can be slower than zero-copy deserialization, but it supports all</em> possible data inputs:</p>
use</span> serde</span>::</span>Deserialize</span>;</span></span>
use</span> serde_json</span>;</span></span>
</span>
#</span>[</span>derive</span>(</span>Deserialize</span>)</span>]</span></span>
struct</span> Foo</span> {</span></span>
    text</span>:</span> String</span>,</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> json</span> =</span> r</span>#</span>"</span>{ "text": "Go to C:\\Users\\bd\\Desktop" }</span>"</span>#</span>;</span></span>
</span>
    let</span> foo</span>:</span> Foo</span> =</span> serde_json</span>::</span>from_str</span>(</span>json</span>)</span>.</span>unwrap</span>(</span>)</span>;</span></span>
</span>
    println!</span>(</span>"</span>{</span>}</span>"</span>,</span> foo</span>.</span>text</span>)</span>;</span> //</span> Go to C:\Users\bd\Desktop</span></span>
}</span></span></code></pre>
This kind of issue will arise when deserializing other escape codes in JSON, such as \n</code> and \t</code>. It can also occur when using other types that can be zero-copied, such as &Path</code></a>1</a></sup>. Next time you consider using zero-copy deserialization, be sure you're ok with limiting what data you can support.</p>
Further Reading:</a>
</h2>

Deserializer lifetimes</a></li>
JSON string with backslashes does not deserialize into borrowed &str</code></a></li>
</ul>
Addendum</a>
</h2>
As @korrat</a> has helpfully pointed out</a>, Cow<str></code></a> can be used as a compromise between &str</code> and String</code>. If you annotate a field with #[serde(borrow)]</code>, it will first try to zero-copy deserialize the string, but will fall back to cloning the data if it needs to be modified.</p>
As a result, Cow<str></code> should be preferred as it offers performance improvements without restricting what data can be deserialized:</p>
use</span> serde</span>::</span>Deserialize</span>;</span></span>
use</span> serde_json</span>;</span></span>
</span>
use</span> std</span>::</span>borrow</span>::</span>Cow</span>;</span></span>
</span>
#</span>[</span>derive</span>(</span>Deserialize</span>)</span>]</span></span>
struct</span> Foo</span><</span>'</span>a</span>></span> {</span></span>
    //</span> Try to borrow the string when possible, but clone it when necessary.</span></span>
    #</span>[</span>serde</span>(</span>borrow</span>)</span>]</span></span>
    text</span>:</span> Cow</span><</span>'</span>a</span>,</span> str</span>></span>,</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    //</span> No changes need to be made, the string can be borrowed.</span></span>
    let</span> json</span> =</span> r</span>#</span>"</span>{ "text": "Hello, world!" }</span>"</span>#</span>;</span></span>
</span>
    let</span> foo</span>:</span> Foo</span> =</span> serde_json</span>::</span>from_str</span>(</span>json</span>)</span>.</span>unwrap</span>(</span>)</span>;</span></span>
</span>
    assert!</span>(</span>matches!</span>(</span>foo</span>.</span>text</span>,</span> Cow</span>::</span>Borrowed</span>(</span>_</span>)</span>)</span>)</span>;</span></span>
</span>
    //</span> Changes need to be made, the string must be owned.</span></span>
    let</span> json</span> =</span> r</span>#</span>"</span>{ "text": "Hello,\nworld!" }</span>"</span>#</span>;</span></span>
</span>
    let</span> foo</span>:</span> Foo</span> =</span> serde_json</span>::</span>from_str</span>(</span>json</span>)</span>.</span>unwrap</span>(</span>)</span>;</span></span>
</span>
    assert!</span>(</span>matches!</span>(</span>foo</span>.</span>text</span>,</span> Cow</span>::</span>Owned</span>(</span>_</span>)</span>)</span>)</span>;</span></span>
}</span></span></code></pre>
In the initial release of this post, I incorrectly wrote that Cow<str></code> does not support zero-copy deserialization. This isn't the case, you just need to annotate the Cow<str></code> field with #[serde(borrow)]</code>. Don't forget that attribute, or Cow<str></code> will just be equivalent to String</code>! See the serde</code> docs</a> for more information and examples.</p>



Be especially careful about using this type. Since it cannot deserialize backslashes, you're essentially eliminating support for Windows paths. ↩</a></p>
</li>
</ol>
</section>


Announcing bevy_lint v0.2.0
2025-03-19T00:00:00+00:00

    Hello there, my dear

Hi, I'm BD103 </a> </h2>
Last year</a> I talked about how I got involved with Bevy and how I found my place working on the CI infrastructure. This year, you’re in for a treat, as I took my work in a fun, new direction!</p>

Tim</a></a> </h3>
easy web support</a> and the upcoming `getrandom</code> fix</a>, were implemented by of you. You've truly left your mark on the Bevy community2</a></sup>, and it's been wonderful working alongside you!</p>`

BD103's Blog

Rust Hashing Cheat Sheet

Bevy's 5th Birthday: Year of the Linter

Be Careful Zero-Copying Strings with serde

Announcing bevy_lint v0.2.0