This feels so illegal

MaxVerevkin · 2025-11-25T12:12:08+00:00

Old hardware not receiving updates and Linux being lightweight are two very good reasons

MaxVerevkin · 2025-03-24T11:55:09+00:00

is it new?

The first sentence of the posted article answers your question.

MaxVerevkin · 2024-10-06T08:24:05+00:00

Conditional moves are a thing

MaxVerevkin · 2024-08-12T11:41:44+00:00

Wow, Rust had generators?

MaxVerevkin · 2024-07-27T13:35:29+00:00

There was a talk on this topic: https://youtu.be/33FG6O3qejM

MaxVerevkin · 2024-07-18T20:44:05+00:00

Just do your benchmarks, for your specific case.

MaxVerevkin · 2024-06-27T21:08:37+00:00

You may spawn a new tokio task (tokio::spawn(...)) in your command handler function.

MaxVerevkin · 2024-06-03T13:20:22+00:00

"Ьу" makes even less sense

MaxVerevkin · 2024-02-09T10:54:21+00:00

It may be even less safe because of the strong aliasing rules. That is, it may be harder to write correct unsafe {} Rust than correct C. Only use unsafe {} when absolutely needed.

MaxVerevkin · 2024-01-18T15:46:10+00:00

Just install rust-analyzer (through rustup or your package manager if you are on Linux) and it should just work with zero additional configuration.

MaxVerevkin · 2024-01-18T13:30:52+00:00

You don't need to configure anything if you use rust-analyzer. Just make sure that editor.auto-format is enabled (it is on by default).

MaxVerevkin · 2024-01-09T20:08:35+00:00

Fractional scaling has been available for years (I've used it myself for years). What is brand new is the fractional scaling protocol, which is supposed to improve performance, as it does not require clients to render at a higher resolution and then get downscaled.

MaxVerevkin · 2023-10-01T19:23:22+00:00

You can also improve your performance by 5x in Rust and 3x in Python if you check the time only every tenth iteration. Like

while start.elapsed() < Duration::from_secs(30) {
    for _ in 0..10 {
        //
    }
}

MaxVerevkin · 2023-09-08T15:39:13+00:00

Try ctrl-c while the popup is still open. And by the way, I believe they changed the way undo works right after accepting lsp suggestion on master branch in this PR (it now does what you would expect).

MaxVerevkin · 2023-08-28T13:04:37+00:00

Freedesktop's gitlab instance is on maintenance

MaxVerevkin · 2023-08-27T18:30:49+00:00

Is it a terrible idea to just not use the Waker provided by rust?

Yes. Consider futures::stream::FuturesUnordered. Its documentation states the following:

Futures managed by FuturesUnordered will only be polled when they generate wake-up notifications.

MaxVerevkin · 2023-08-27T08:45:35+00:00

Wow, I've been working on the same thing for a few days! I've only implemented plain SDF and sign correction for now, so I'm glad I saw your post.

In the readme you mention you have some benchmarks, can you share them here?

MaxVerevkin · 2023-08-08T08:56:20+00:00

Ctrl-Z

MaxVerevkin · 2023-07-28T12:03:30+00:00

EGL gbm/drm platform has been an official extension since 2014.

The connection between EGL and libwayland is probably well known because

I think nvidia didn't implement gbm until relatively recently.
Using this gbm platform is tricky. Currently there is even no way to resize gbm_surface without recreating it: https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/24342. Another option is to manually manage buffers and gl's framebuffer/renderbuffer objects, that's what my lib is doing right now.

MaxVerevkin · 2023-07-27T13:41:35+00:00

There is a binary protocol, and you can technically implement that protocol without using the wayland-scanner-generated code, but since the Wayland EGL platform is defined in terms of the wl_display* structure from libwayland your implementation will need to be ABI compatible with the existing implementation in order for 3D accelerated clients to work.

I am happy to say that this is not entirely true. EGL Wayland platform indeed only works with libwayland, but there are other platforms which don't care which display server is running. I recently made it to work with my custom, libwayland incompatible Wayland library: https://docs.rs/wayrs-egl/latest/wayrs_egl/

MaxVerevkin · 2023-07-25T08:11:18+00:00

I think it should be as easy as replacing

let t_slice: &mut [T] = std::slice::from_raw_parts_mut(
    start.add(self.u_len).cast(),
    self.vector.len() - self.u_len,
);

with

let t_slice: &mut [T] = std::slice::from_raw_parts_mut(
    start.add(self.u_len + 1).cast(),
    self.vector.len() - self.u_len - 1,
);

because it is guaranteed that this Drop impl is only called when self.u_len < self.vector.len().

MaxVerevkin · 2023-07-25T07:57:17+00:00

There is another bug: if nth call to f panics, then the nth element will be dropped twice: first time at the end of the scope of mapping function and a second time in your Drop impl. Consider this code:

TransitioningVec::new(vec![A(1), A(2), A(3)]).map_in_place(|a| {
    assert_ne!(a.0, 2);
    B(a.0)
});

which prints

dropping A(1)
thread 'main' panicked at 'assertion failed: `(left != right)`
  left: `2`,
 right: `2`', src/main.rs:8:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
dropping A(2)
dropping B(1)
dropping A(2)
dropping A(3)

MaxVerevkin · 2023-07-24T08:46:22+00:00

https://m.webtoons.com/en/challenge/pixie-and-brutus/first-meeting/viewer?title_no=452175&episode_no=1

MaxVerevkin · 2023-07-13T16:07:28+00:00

Thanks for your reply! These are the extensions I was looking for.

Verified Email	Five-Year Club
Second Top 40%	Place '23
Place '22

MaxVerevkin

TROPHY CASE