dtolnay/request-for-implementation

Crates that don't exist, but should

Crates that don't exist, but should

A collection of Rust project ideas. >Skip the introduction and jump to the list<

These are bite-sized ideas for which someone already has a mostly clear design in mind. They are waiting on an interested library developer to carry through the implementation and own the code. The requester should be prepared to offer guidance on any API design questions that arise during implementation.

Ideas should result in their own useful library, even if that is just a few functions. Ideas for which the code would go in some existing project should be filed on that project's issue tracker rather than being listed here.

Many of these would make neat projects for a Rust beginner.

Contributing

To work on an idea, click through on one of the "Design" links to read more about the idea and coordinate as you make progress on the library.

To add a project idea, please file an issue with enough detail so that anyone interested can understand the design you have in mind. Include links to relevant background material if possible. Then send a PR adding a link to your issue. Feel free to add a new heading if none of the existing ones apply to your idea.

Getting help

For some ideas the person who posted them may be available to provide mentorship on the design thread, but this is not a requirement. If you find yourself stuck, swing by the Rust Users forum or the Rust Discord chat channel. Explain what you are working on and where you got stuck, and they will be able to help you out.

If you are interested in providing mentorship to people working through a project idea, subscribe to individual design threads or "Watch" the whole repo (here) to follow all the threads.

Relationship to Not-Yet-Awesome Rust

The not-yet-awesome list is similarly a catalog of project ideas, but the scope is much broader than the one here. Some examples from their list:

• A stream processing pipeline with back pressure for asynchronous processing;
• A deep learning toolkit with GPU support;
• A mature framework for Windows native UI.

These are things that will involve a significant amount of design work, feedback from multiple stakeholders, a responsive and dedicated maintainer or team, and likely months to years of bake time before they would be considered awesome.

Their list does include some smaller project ideas too but very few of them come with a thought-out design that someone could get started implementing immediately.

In contrast, the Request For Implementation list is intended for ideas where a design mostly already exists and can be concisely described. It should be ready for someone to dive straight into code and it should be clear when a library has accomplished the intended design.

🚜 Command line

Cargo subcommand to perform pluggable expansions against rustdoc [Design]

Completed ideas:

Library for a Cargo subcommand to find components installed under a different toolchain [Design] — [Outcome]

Tool to enforce that Cargo.toml dependencies are written in sorted order [Design] — [Outcome]

Tool to streamline running public crate examples [Design] — [Outcome]

🚁 Cross platform

Functions for normalizing and joining paths with consideration for UNC on Windows [Origin] — [Design]

🚛 Data structures

Completed ideas:

Library for writing const-compatible phantom types with explicit variance and autotrait behavior [Origin] — [Design] — [Outcome]

Types for checked arithmetic on instants and durations [Design] — [Outcome]

🚄 De/serialization

A dtd macro that you could point at an XML DTD file and have it generate struct definitions for you [Origin] — [Design]

Serde format for in situ JSON deserialization [Origin] — [Design]

Minimalist YAML parser with support for borrowed string slices [Origin] — [Design]

Miniserde utilities library, like adapters for Display and FromStr [Origin] — [Design]

Attribute macro to generate de/serialization functions for fields of big array type [Origin] — [Design]

Completed ideas:

Macro to serialize and deserialize trait object using internal type tag [Design] — [Outcome]

Attribute macro to skip serializing all fields of Option type [Origin] — [Design] — [Outcome]

Derive macro to derive Default from Serde default attributes [Origin] — [Design] — [Outcome]

Derive macros to serialize and deserialize struct as an array of values [Origin] — [Design] — [Outcome]

Derive macro to compute Bincode size of type [Origin] — [Design] — [Outcome]

Attribute macro to apply prefix to name of serialized fields or variants [Origin] — [Design] — [Outcome]

Wrapper to strip pseudo-JSON comments from an io::Read input stream [Origin] — [Design] — [Outcome]

Miniserde derive macro that supports enums [Design] — [Outcome]

Data format adapter to expose control over the representation of bytes [Origin] — [Design] — [Outcome]

🚂 Procedural macros, Syn

Completed ideas:

Query syntax and extractor for syntax tree elements [Origin] — [Design] — [Outcome]

Attribute macro to make a trait boxed clonable [Design] — [Outcome]

Procedural macro reimplementation of quote! to resolve some longstanding limitations [Design] — [Outcome]

Library to inline out-of-line mod items and resolve #[path = "..."] [Origin] — [Design] — [Outcome]

Library for parsing function signature without parsing function body [Origin] — [Design] — [Outcome]

Derive macro for computing total memory occupied by a data structure [Design] — [Outcome]

Library to serialize and deserialize Syn syntax trees [Design] — [Outcome]

Testing tool for comparing output of macro against expected source code [Design] — [Outcome]

Library + tool to list all source files of a crate [Design] — [Outcome]

Attribute macro for conditional compilation options [Design] — [Outcome]

🚠 Visualization

Completed ideas:

Minimal API for generating color scheme for a chart that needs n colors [Origin] — [Design] — [Outcome]