Roadmap, milestones, and functionality levels

[khyperia]

High-level reasons for the project

Pros compared to glsl/hlsl/etc.:

• Rust is a nicer language: memory saftey, traits/generics, and so on.
• Whole codebase in one language is good.
• IDE support (syntax highlighting! autocomplete! omg!)
• Cargo and crates.io (see also: ideas around shadergraph-like things)
• Debugging on CPU? (from println to true debuggers)

Cons:

• glsl has huge ecosystem with an insane amount of resources being pumped into the status quo, hard to beat that
• glsl is a specialized language, having a general purpose language be restricted down to GPU-allowed stuff is awkward.

Functionality levels

Each level distinguishes a milestone of achievement, and requires a certain level of commitment to get there. However, items here are extremely fluid, frequently span multiple levels, and can be worked on non-sequentially and in parallel.

Level 1 (#5), "prototype":

• The compiler outputs a functional spir-v binary that can be executed, even if doing so is complex, user-unfriendly, and high-effort.
  • There's an implicit "compiler is better and supports more stuff" work item for every level past this.
• Headcount commitment: At least one dedicated compiler engineer, a few support engineers. Code is suspiciously already in.
• Time commitment: A tad over 2 months. Exactly. Wau, that's an accurate "estimate"!

Level 2 (#36), "that's a rusty skybox":

• Ark is using rust-gpu shaders in "production". The system may be arkane (:3) and hacked together, but it's functional.
• Headcount commitment: At least one dedicated compiler engineer, a few support engineers. Same as level 1.
• Time commitment: 0.5-1 month. Likely to be blurred with level 3.

Level 3, "it's friendly now":

• Build system integration is functional and user-friendly - e.g. someone can specify a crate path in build.rs, and include! the resulting spir-v binary. ("Build system" #48)
• The spirv-std library has the basics. (e.g. Language feature: barriers #8, Investigate custom repr for GPU memory #11, Investigate adding fast-math functions #12, Vector types #34, GPU-side layout/binding attributes #45).
  • Implicit "stdlib is even better" item for every level past this.
• The compiler is reasonably friendly (Capability computation UX #42, Convert panics to compiler errors #43, Zombies in non-core code should be compiler errors, not zombies #44).
  • Again, implicit "compiler is even friendlier" item for every level past this.
• Consider open-sourcing here, as it will be usable externally (even if a little difficult to do so). (Open up and announce project #37)
• Headcount commitment: Preferably multiple compiler folks, at least one build system engineer, community manager for open-sourcing and guiding that community, some partial-time folks for various tasks (stdlib work) and feedback (both actual part-time and folks in other pods dipping in from time to time)
• Time commitment: 3 months (?)

Level 4, "time to submit a talk about this":

• Ergonomic bindings, i.e. generating host-side code (Ergonomic Rust CPU to Rust GPU / SPIRV bindings #10)
  • Note this begins to be framework-dependent, having a hard dep on e.g. ash or vulkano specifically. We need to be careful here to make sure the underlying compiler is still usable elsewhere.
• Better compiler support for IDEs (having the gpu restrictions show up in rust-analyzer)
• This is where using rust on the gpu instead of glsl starts to flicker as a candle of hope.
• Headcount commitment: Uncertain, likely similar to level 3.
• Time commitment: 2 months (?)

Level 5, "I could see this in a released game":

• Rendergraph shenans (Render graph design #21)
• Upstream the compiler
• Clippy rules
• Rust on the GPU starts to really shine as a useful tool.
• Headcount commitment: Uncertain. Depends on what development style we want: could dump a bunch of people on it (a bit more than level 3) and get it beautiful quick, or have a couple folks slowly burning on it for a while.
• Time commitment: 4-6 months (??) - (Ashley has no knowledge of how long rendergraph shenans would take to implement)

Level 6, "all the cool kids use shaded rust":

• Move through rust support tiers until we hit tier 1
• Begin to revolutionize shader development (hopefully~), really hitting all the use cases where Rust is great at this.
• Headcount commitment: Uncertain, likely similar to level 5.
• Time commitment: unbounded, uncertain, will definitely have more roadmap discussions before we get here

Feel free to edit this issue with more thoughts or to shuffle things around.

[khyperia]

I don't think this issue reflects our current roadmap, and the things we've learned since I wrote this invalidates quite a bit of it, so we should probably close this issue to not give anyone wrong ideas. If someone feels otherwise, feel free to reopen.

[John0x]

Hey :)
I'm in the process of planning some projects that may depend on future functionality of rust-gpu. Is there a replacement for this roadmap, since you've stated that this issue isn't up-to-date anymore?

Is the roadmap under the projects tab still accurate and can be considered a replacement for this issue?
Btw. this issue is still linked there (https://github.com/EmbarkStudios/rust-gpu/projects)

And keep up the great work 👍
I'm extremely excited for the future of rust-gpu and I'm sure it will be going places ❤️

[ckaran]

Hey, I keep dropping in on the project from time to time to see how it's going. I noticed that the last comment on this issue was from 15 April 2021, and the last update to the roadmap was back on 1 April 2021. I know you guys have been working hard since then, I can see the commits in the repo, but that doesn't give me a clear picture of where things are. Can you please post updates somewhere? Thank you!

[repi]

hi, work indeed continues on! but we do not at this time have a public roadmap or updated summary of where we are at. but in a few of months we'll have more people joining to work on the project and will do some planning and triage and see if we can share more about our plans and support.

[ckaran]

Thank you for the update! I'm really looking forwards to one day (I hope) having everything Just Work™; I know very, very little about how to write, let alone optimize, compute shaders but they would be incredibly helpful to have working from straight rust.