cargo-asm VS rust_minifb

cargo asm might be useful here (if you can't use godbolt).

They should be inlined in release mode. You'd have to verify by checking the assembly, though, which could be done directly in the Rust playground or with a tool like cargo-asm.

You can use cargo asm - not sure if you can integrate it with VSCode, but even from a terminal it's a pretty convenient tool.

There's probably a built-in one somewhere, but I suspect it'd be easier just to install https://github.com/gnzlbg/cargo-asm

I don't know if there's a way to do a side by side comparison but cargo-asm uses the source mapping information from rustc to annotate chunks of assembly with it's respective rust code, though it's an imperfect process.

After that you would need some tools to help figure out how to achieve improvements. That will depend on your system and personal preferences. As the other commenter suggested, perf is a good choice on linux. I personally like to look at the generated assembly, using either cargo asm, godbolt, or just rust playground.

Doesn't this already exist? https://github.com/gnzlbg/cargo-asm

From the flamegraph, we knew which function was taking the majority of the time, which we briefly described above. We started by looking at the assembly code it generated to see if there were any opportunities to make it faster. We did this with cargo-asm.

You're best bet at the moment is probably using cargo-asm to inspect the function assembly to see when it is performing the correct TCO.

Well, it depends on how you use it; writing to an image buffer isn't much less efficient than writing to any normal buffer (in fact, although displaying your scene to a window efficiently is important, your main bottleneck will be the actual ray tracing loop). You may want to read this article for a practical example of using an ImageBuffer to create and draw a texture with Piston. Other window backends you could use, apart from pixels which was already mentioned in another comment, include minifb and Mini GL, though I haven't personally used them.

After watching the Numberphile video on this formula, I decided to implement it in Rust for fun. It uses minifb for the window creation + framebuffer.

Before I could implement the display output, I needed something to draw the images onto. There are quite a few Rust crates available to create a GUI window and update it with 2D graphics. Most of these are of course intended for making games, and also include ways of getting key presses as input, which I'll also need. I looked at Piston, which I've used before on other projects, Macroquad, which also supports web assembly as well as desktop targets, Pixels, which is intended specifically for 2D games, and Minifb, which is also specifically for 2D applications, but is much simpler. I also tried out libretro, which is specifically made for video game emulation, but I found it much more restrictive than the others because of it's narrow focus.

There's several different approaches you could take, but I'd probably suggest macroquad as the easiest. I've also used minifb for windowing + a drawing library like raqote or tiny-skia.

I don't know much about Rust, but I used the C version this library, and I think this is as simple as it gets: Rust MiniFB. Hope this helps

A very simple color manipulation library backed by a u32. My use-case was for use with minifb which uses a u32 frame buffer. Feedback appreciated.

If all you need is a pixel/frame buffer I'd suggest either pixels-rs or minifb.

In my experience, it really makes no difference what rendering backend you use for something as simple as a NES emulator. The 'pixel_renderer' that i wrote basically does the simplest possible thing i could think of - it takes a pixel buffer in cpu memory, copies it over to the gpu, turns it into a texture and stretches it to cover the entire screen. There seem to be many crates out there that do just this - my choice to roll my own was really one out of curiosity and completionism more than anything.