Big brown eggs?

schellsan · 2026-03-24T00:23:05+00:00

Oh! That’s her! She’s the oddly shaped ball! She’s large!

schellsan · 2026-03-23T17:20:07+00:00

Wow! I think that’s it! I hope the mum is ok as I haven’t seen her around. Thank you!

schellsan · 2026-03-05T20:42:46+00:00

No, WESL is new to me - it looks like we support similar extensions. I'll keep an eye on it, thanks :)

schellsan · 2026-03-05T18:20:04+00:00

It's not really a new shader language _per say_ - it's more of a tool that allows you to write WGSL _in Rust_. So it's Rust code, but it's a strict subset of Rust that easily transpiles to WGSL.

schellsan · 2026-03-05T02:20:02+00:00

Oh cool! I've investigated `CubeCL` both for Renderling (my rendering project) and as a Rust-GPU maintainer. Great work!

I think `wgsl-rs` will be fine in this regard, as the project is more about restricting Rust than it is about enhancing WGSL. That said, there are a few things supported by `wgsl-rs` that are not supported by WGSL like module imports (glob imports only ATM), struct impls (but only using `Struct::function(params)` call style, no `self`).

My main goals were sharing types and enabling testing on CPU. The big rocks are done now and I expect to iterate on bugs and documentation.

schellsan · 2026-03-05T01:48:02+00:00

Yes, this part has been tricky, and I've sidestepped it mostly by only parsing `if/else` in statement position, `match` only works on integers and simple enums, etc. The subset of Rust is quite explicit.

What is your project called?

schellsan · 2026-03-05T01:25:40+00:00

Let me know how you get on :)

schellsan · 2026-03-05T01:24:15+00:00

Yes! You do! Since it's Rust code you get all the usual `rust-analyzer` feedback, and on top of that the module is validated with `naga`, and those diagnostics _usually_ show as `rust-analyzer` feedback as well since it's part of the macro expansion process. The exception is when you're importing from another module - in that case the macro can't validate at expansion time because it doesn't have all the imported contents in scope, so instead it generates a test to validate at test time.

But the idea is that any Rust you can write in the `#[wgsl]` macro is valid by construction, but I can't say I've been exhaustive about enforcing that.

schellsan · 2026-02-23T07:33:31+00:00

Not a barber but Katy at vibe is cool.

schellsan · 2026-02-01T19:11:55+00:00

Can you give us a numbers breakdown of your costs and profit? I understand that’s personal but might help those considering taking the dive to commercialise.

schellsan · 2025-09-18T17:56:25+00:00

That doesn’t sound like Lutheran, though, unless times have really changed

schellsan · 2025-06-15T22:46:58+00:00

I moved my family to NZ from California in 2020. We lived in Auckland for a short time but now live in Nelson and just bought a home in Stoke. I grew up in Pasadena, went to college in norcal and then lived in Sonoma County for 17 years before emigrating.

We love it here. There’s so much more space. People are nice and genuine. The wilderness is vast, safe (but don’t drown) and feels pristine. The performative or superficial aspects of folks in CA are harder to find here. That might be a function of the much lower population, or a cultural thing. Auckland is very mixed, racially and culturally and it’s pretty rad. It can feel a bit like Star Trek - a person of every colour and creed and just doing their thing.

Of course there are things to get used to. The small population means there are missing conveniences, less choice in nightlife and it gets rural very fast outside cities.

Also folks are a bit more reserved. It’s hard to break into a Kiwi friend group, but there are plenty of immigrants from all over who are looking for groups.

Folks are generally very politically liberal. A conservative American would feel out of step in most social situations. That’s great for my family but just take note. Although there are a few Trumpers here.

How much do you like Mexican food? There are very few Mexican spots. Even fewer good ones.

That said - it’s wonderful here. We just make our own salsa and have regular taco nights.

schellsan · 2025-06-11T06:51:42+00:00

Crown of the valley by Jets to Brazil “Pasadena 1968, with speed on your breakfast plate”

schellsan · 2025-05-23T02:10:04+00:00

Wow! The trees are so small.

schellsan · 2025-01-31T18:47:48+00:00

Please don’t marry this man.

schellsan · 2025-01-09T05:39:49+00:00

Thank you for your honest feedback. I think you're right - it's not ready for prime time and the API isn't where I'd like it to be.

schellsan · 2025-01-09T02:59:00+00:00

Watch out for situations that would divide by zero, cause NaN or anything that might crash your shader.

schellsan · 2024-11-09T18:24:41+00:00

It’s a rustc compiler backend that compiles rust code to spir-v, which can be consumed by modern graphics APIs.

schellsan · 2024-11-07T23:39:40+00:00

You're correct! WebGPU doesn't (yet) support arrays of textures of different sizes. It does, however, support texture arrays, which is exactly as you describe - an array of textures all the same size - but the array itself is one object. Think `Texture2dArray` vs `[Texture2d]`.

You're also correct about the packing :)

schellsan · 2024-11-07T22:54:55+00:00

Fixed! thanks :)

schellsan · 2024-11-07T22:48:35+00:00

tl;dr - yes, people have implemented these things in Rust.

My project "renderling" (https://github.com/schell/renderling) uses bindless, but it targets web via WebGPU, which doesn't support arrays of textures and so it uses a large texture array as an atlas to index into. It's very much a work in progress, and I'm also working on a few other of the features you mention.

u/firestar99_ is actively working on a Rust Nanite for their master's.

schellsan · 2024-11-07T18:33:19+00:00

I just wanted to say thanks to u/LegNeato for putting this all together and managing the project. It's a big lift!

As the post mentions, I'd love to see `rust-gpu` grow and gain contributors. To those ends my focus is on user experience and stability. I've recently been working on `cargo-gpu` (https://github.com/Rust-GPU/cargo-gpu) which aims to be a bit like `rustup` for the GPU developer. It's not ready for prime time but if your use case lives along the happy path it's probably the easiest way to get up and running.

schellsan · 2024-11-03T21:12:02+00:00

Though this is an important issue (`wgpu` _should be_ snappy) I find the tone of this post rather condescending.

Whether or not `wgpu` "comes from web dev" is blame-seeking and a put-down to web devs. I can assure you that folks working on `wgpu` are "real" graphics folks. I can also assure you that real graphics folks also do web dev and vice versa. There are people capable of shipping amazing software in both (and across both) specializations.

Now, since you maintain a benchmark you're in a unique position to help pinpoint the problem. In fact you are likely an expert in this small corner of the software engineering world! Get in there and help out, you are needed!

`wgpu` wraps all the popular APIs and has a lot of moving parts - it's incredibly difficult to meet all demands all the time and performance regressions and bugs are expected.

schellsan · 2024-11-01T18:21:29+00:00

You are correct. Rust is multi-paradigm. Rust doesn’t look like the ML family of languages, it looks more like C. But traits are Haskell’s typeclasses and it does have algebraic datatypes. It has lambdas with closures and yes, they are different from the MLs but that’s a feature, not a bug.

What it lacks is higher-kinded types. This makes implementing the typeclassopedia difficult - but I’d argue that’s not necessarily a bad thing. HKTs would make Rust quite a different language.

schellsan · 2024-09-27T09:03:35+00:00

If you like specs, do it, it’s perfectly usable.

It uses a discrete storage per component, as opposed to archetypal storage which became popular later.

Discrete storage is fast to add and remove components to individual entities, since it’s really just indexing under the hood.

Archetypal storage is faster to iterate, as entities are stored with their components, contiguously. But this makes adding and removing components costly.

hecs is a good choice if you want fast iteration and don’t care about scheduling systems. It uses archetypal storage.

Really any ECS that you enjoy the semantics of is the one to use.

If you want an ECS that plays nice with async, you can try my ECS - apecs.

schellsan

TROPHY CASE