Calling all rustaceans, rustafarians, ferrosities, and rustlers - we’ve got an exciting update!
Active full time work on a Rust-IPFS implementation has commenced, building on the great work by
Parity (opens new window) in rust-libp2p. Equilbrium (opens new window) is spearheading the new community and
implementation with support from Protocol Labs, and is looking for additional Rust devs itching
to help build a new language implementation of the InterPlanetary File System combining the
performance and resource utilization benefits of Rust with a keen eye on conformance to the IPFS spec. Read more on the Equilibrium Labs blog (opens new window)!

Why Rust IPFS? Why Now?

Rust, the programming language, has enjoyed a recent spike in popularity. This is due both to its
inclusive community, and also being a safe systems language with performance comparable to C and
C++. An IPFS implementation written in Rust only makes sense. Additionally, the community has been
asking for a while now (opens new window), for a number of use cases:

1. Usage in resource-constrained systems such as Industrial Internet-of-Things (IIoT) controllers
2. Portability of certain subsets of the IPFS stack into WebAssembly
3. Usage of IPFS functionality and APIs via native Rust function calls via inclusion as a Rust crate.

Given that, it's no surprise that Rust-IPFS was also one of the IPFS 2020 Theme Proposals (opens new window) suggested in our community-driven IPFS 2020 Roadmapping Process (opens new window) - and that the community quickly rose to the challenge. Equilibrium, an active participant in many dweb infrastructure projects, stepped up to take on core implementation and stewardship of this new language implementation, with support through the new IPFS DevGrants program (opens new window) to provide coordination and maintainership for passionate developers in the wider Rust community.

With both community demand and active participation, the time was ripe for the Rust-IPFS effort to be revitalized and reborn!

Leveraging Community Efforts

The IPFS community is a talented group of people with an impressive array of high quality work in the Rust space already. There's the aforementioned
rust-libp2p (opens new window), which is already used by the likes of Polkadot, Substrate, and Lighthouse; there's ferrismtg's rust-ipfs-api (opens new window) which is already doing wonders in providing a bridge from the Rust world; and of course David Craven (opens new window)'s rust-ipfs (opens new window), which is the foundational work behind this latest endeavor.

Instead of forking and/or starting fresh, this project aims to support and build on the impressive amount of progress that's already been made, helping carry the torch across the finish line while incorporating and including the community of passionate Rust contributors in the process.

What can be expected, and when?

As you can see in the Rust-IPFS DevGrant Roadmap (opens new window) implementation work
takes place mostly over early Q2 2020 and covers the use case of IPLD applications,
targeting the low-level blockstore, libp2p integration, and IPLD-related functionality
such as ipfs dag put and ipfs dag get.

To learn more about the effort, you can:

1. Visit the rs-ipfs organization (opens new window) on GitHub
2. Read more about this effort on the Equilibrium Labs blog (opens new window)

You can help!

Community participation in making Rust-IPFS a reality is encouraged and welcomed! If you
want to pitch in, here are a few ways:

1. Star and watch the GitHub repo (opens new window)
2. Take on the development efforts associated with IPFS APIs deemed out of scope for the initial grant milestones (opens new window)
3. Look for help-wanted issues that are marked as needing help from the community (opens new window)
4. Back IPFS Rust on OpenCollective (opens new window)