Some interesting learnings from RustConf

Just wrapped up an amazing two days at the RustConf in Portland.

Above all it gave me a strong impression that we are really working with the right tools (Rust/WASM) and that we share the space with many other projects with plenty of overlap.

I made some notes of some of the more interesting learning outcomes for me to share within the team but I figured this might be interesting to those in the community as well so here they are:

  • This really was more like WASM conf than RustConf. A lot of talk and excitement about WASM and what it can bring not just to the web but also for general secure and portable execution of code.

    • Lin Clarks closing keynote was all about the Wasm Interface Types proposal ( which is something we could consider taking on which would make it much easier to support non-rust HDKs
    • Got into a great discussion about WASM binary sizes. Apparently it is mostly due to Rusts large standard lib, improper compiler flags etc. When compiled properly Rust should be the most compact and performant wasm target language (so the problem is us ;), and Serde…).
    • Recently in Berlin there was a conference specifically for “blockchain projects using WASM”. Such is the level of adoption in that space.
    • It seems like everyone else is just as perplexed about which WASM runtime to use as we are. I talked to people from 5 different projects using 5 different runtimes! (Wasmer, Wasmi, Lucet, Wasmtime, V8!!)
    • Met some people from Wasmer. Apparently it now supports WASM OP gas calculation which is kinda cool. This seems to be a very active project at the moment.
  • Had a great chat with people from CloudFlare. Apparently Rust service workers are fully production ready and are currently being used as such. This could be useful for Holo to reuse existing crate ecosystem (dpki etc)

  • Learned about tokio-trace (now called tracing)(, a crate specifically designed for tracing/logging in complex async programs. Logging that captures context, causality and structure. Also supports profiling, metrics etc. This or a similar approach would likely be the best next step to improve our logging.

  • Constant eval in Rust is going to be super powerful soon. Just a kinda cool aside note

  • Useful tool for writing proc macros (

  • Learned about how the Rust team is using something called the Orbits model for developer relationships, something we can perhaps learn from (

  • Got into a great discussion about Verifiable Delay Functions (VDFs) with the team from Solana. Got totally nerd sniped. I feel there is possibly a really great way to use this in Holochain for voting and other time consensus related things. Excited to learn more.


Solana is a super cool project. Did Holo team went to event? Mozilla was there too.

I am super interested in the Variable delay Functions. I need time locked smart contracts for mh project and this could be an innovative approach

Yes, Solana’s use of VDF for their proof of history is a very innovative way for nodes to have a objective sense of events ordering without the need to communicate with other nodes which ensure no communication overheads that other blockchains will face.

Solana also have many innovations that help them scale from block propagation, usage of GPU for parrallel processing of smart contracts, scalable DB, solving the large ledger/state problem etc.

Some useful links that are good for references: