What's everyone working on this week (7/2019)?


New week, new Rust! What are you folks up to?

1 Like


Continue marriage C Portal App with IUP UI and ported software renderer from C to Rust

1 Like


I released a crate last week (partial implementation of IEEE 802.15.4). This week, I’m continuing work on releasing the next one, my DW1000 driver. Made lots of progress already, but I fear that getting the documentation up to my standards is going to take a lot more work.

1 Like


Still fixing things in HorseShoe and trying to add a gamma function to the project.



I am continuing work on a byte string library called bstr. A good portion of it is complete, and its API can be seen here: https://burntsushi.net/stuff/tmp-do-not-link-me/bstr/bstr/

I’m still working on API additions and actually trying to use it in other crates to get a feel for it in practice. I hope to use it to delete a fair bit of code in various crates such as csv, xsv and hopefully some of ripgrep’s crates as well.



This weekend I fixed the last remaining bugs in my Chip8 interpreter/emulator (https://youtu.be/HHkoG6OV_VI). Plays all the ROMs I have access to so far, and the process of finding out what bugs I had involved me adding debugging and step backwards support, so that was neat.

This week I"m going to start working on writing code to disassemble an existing rom (including labeling and instruction vs data support) and depending on how far I get on that also create an assembler for it.

1 Like


I finished up a 0.1 version of wl-clipboard-rs, a crate that provides access to the Wayland clipboard for terminal apps and other applications which don’t have any windows.

1 Like


Bug hunting in my simulator in the hope of getting everything working in time to write a paper for IROS.

1 Like


I’m still working on Stochastic Progressive Photon Mapping (SPPM). It starts to look good (similar to the C++ code):

But the iterations stop early because light.sample_le(...) method returns black at some point (which does not happen in the C++ code):

> ~/git/github/rs_pbrt/target/release/examples/rs_pbrt -i imagewritefrequency.pbrt
pbrt version 0.5.0 [Detected 8 cores]
Trace photons and accumulate contributions ...
light[0]: pdf_pos = 1, pdf_dir = 1.1879485, le = RGBSpectrum { c: [0.0, 0.0, 0.0] }

The (early) return is caused by these lines:

                        let le: Spectrum = light.sample_le(                                                                                 
                            &mut photon_ray,                                                                                                
                            &mut n_light,                                                                                                   
                            &mut pdf_pos,                                                                                                   
                            &mut pdf_dir,                                                                                                   
                        if pdf_pos == 0.0 as Float || pdf_dir == 0.0 as Float || le.is_black() {                                            
                                "light[{}]: pdf_pos = {}, pdf_dir = {}, le = {:?}",                                                         
                                light_num, pdf_pos, pdf_dir, le                                                                             

Something to debug during the next couple of days. Full details can be found in the link above (issue #86) …



I am actively working on miniserve, it’s not my project, though I’m trying to contribute to make it the “simple HTTP server” everyone would want to use. And I think we’re not far from that !

1 Like


Something to debug during the next couple of days.

All fixed now:

The only thing left to do is to make that part of the code multi-threaded



I rewrote https://github.com/chancancode/rust-delegate using procedural macros, it was surprisingly simple.



Posted a development update for my game:

1 Like


Last week I prepared and recorded a second episode for the Rust Simplified series and the result was unacceptable. I’m still learning the best process to produce these episodes so this week I’m refining the way in which I prepare an episode and I hope to record it this weekend and release it Monday morning.

Once I’ve mastered the process I should have episodes out weekly (I’m thinking).



Take a look at rayon, if you can iterate, then you can parallelize fairly easily.