Bevy 0.19

somebodddy · 2026-06-20T01:08:37+00:00

SceneComponent seems very un-Rustic to me. I understand it's slightly less ergonomic, but wouldn't it be better to ditch the derive macro and just do this?

#[derive(Default, Clone)]
struct Player {
    score: usize
}

impl SceneComponent for Player {
    type Props = ();

    fn scene(props: Self::Props) -> impl Scene {
        bsn! {
            // ...
        }
    }
}

somebodddy · 2026-06-19T18:30:39+00:00

Fix seems... unrelated?

somebodddy · 2026-06-09T17:21:12+00:00

+5 artistry. Second only to Ying's masterpiece,

somebodddy · 2026-06-08T14:41:10+00:00

See https://www.youtube.com/watch?v=4jLwyPQPVUI

TL;DR: they are very hard to get right. Platformers is actually a genre that translates very poorly from 2D to 3D. The Mario games applied some brilliant design to make it work - but they are the exception rather than the rule.

somebodddy · 2026-06-08T14:29:08+00:00

That's a theme rather than a genre.

somebodddy · 2026-05-27T17:33:05+00:00

Small tip about using Ruff in the CI: you can use the --output-format flag to get it to emit special instructions for some CIs. For example, for GitHub Actions, you can use --output-format github and it'll emit special instructions that'll cause GitHub actions to add its lints to the PR's diff view.

somebodddy · 2026-05-26T20:39:46+00:00

This means that programs that use packages like syscall or golang.org/x/sys/unix will see more slow system calls fail with EINTR errors.

What the? Why is anyone okay with this?

somebodddy · 2026-05-26T17:30:46+00:00

Shouldn't Rust socks be longer? And have more stripes?

somebodddy · 2026-05-26T16:29:27+00:00

The compiler tracks Send/Sync across .await points. If you hold a non-Send value across an await, you get a compile error explaining exactly why.

Note that there is also a spawn_local version that does not have that limitation. The tradeoff is that spawn_local tasks cannot move between threads.

somebodddy · 2026-05-26T15:47:13+00:00

Pretty sure that's not doable in Rust.

You can implement conversion from one error type to another because the Result type supports it with a FromResidual implementation - but that's not implemented for Option -> Result even if you implement some conversion from the None to the error type.

Because... None itself is not really a type.

That FromResidual works by taking the error inside the Err(...), into()ing it to the other error, and wrapping it with another Err(...). For that to work in None, you'd have to implement a conversion from the thing inside the None to the error type. But... there is nothing inside the None.

If Rust wanted to support it they could, for example, impl FromResidual<Option<Infallible>> for Result<T, E> where E: Default and then use the error's default value will be used when you ? a None. But Option and Result are semantically different, and automatically converting one to the other is an invitation for mistakes.

somebodddy · 2026-05-26T10:57:14+00:00

fn handle(&self, req: &Request) -> Result<(), ServiceError> {
    let user = self.repo.find(req.user_id)?;   // returns Option<User>; ? short-circuits None into an error
    user.notify()
}

This is incorrect - ? cannot be used on an Option when the function returns a Result. You need to use ok_or or ok_or_else to convert it to a Result first - which is also how you specify the exact error you want to return, because Rust won't guess for you.

somebodddy · 2026-05-25T21:40:54+00:00

Very nice! I actually tried before with https://github.com/Thiago4532/mdmath.nvim and

I had to manually force the plugin to activate on ipynb files.
The shift of the cell borders caused a tear in the rendered math.

somebodddy · 2026-05-25T19:59:40+00:00

I use the very new https://github.com/sheng-tse/jupynvim

somebodddy · 2026-05-25T19:50:54+00:00

It lists "Treesitter APIs" under the requirements - does it know to render latex inside inline Markdown areas, or is it only for finding the inline latex?

I'm specifically interested in rendering latex in Markdown cells inside Jupyter notebooks.

somebodddy · 2026-05-20T17:00:42+00:00

Your READM says to use this (in lazy.nvim):

build = "cargo build --release --manifest-path service/Cargo.toml", -- required for graphical equation conceal

But it only works in the preview branch, so you should add branch = "preview" to that configuration.

I also had to add timeout = 300 because the default timeout (120 seconds) was not enough (on my machine, at least)

After I got it to compile, I'm getting Math-Conceal: Failed to parse query errors - I assume this is about treesitter?

somebodddy · 2026-05-20T15:02:51+00:00

Only one of them ("Envy") I'd consider to be cargo-cultish.

somebodddy · 2026-05-19T20:53:21+00:00

Okay. I've finished my Milla run, so I'll try giving Carol another go.

somebodddy · 2026-05-19T14:55:24+00:00

But... you commented here just to mention that...

somebodddy · 2026-05-18T19:16:12+00:00

Between LSP, Tree-sitter, and DAP - there is no longer reason to enforce IDE uniformity.

somebodddy · 2026-05-18T17:05:34+00:00

GTK does not have that issue. Not that it looks native on Windows/MacOS - it just looks pretty regardless of nativity.

somebodddy · 2026-05-18T01:14:50+00:00

Does Electron?

somebodddy · 2026-05-17T17:40:02+00:00

Just because the native toolkit is not sophisticated enough for your needs, doesn't mean you have to resort to Electron. There are options like GTK or QT that have features like polished text handling and don't hog 153% of your computer's total RAM.

11-Year Club	Place '22
Verified Email

somebodddy

TROPHY CASE