Roadmap, milestones, and functionality levels #47

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.