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


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


I’m working on a rewrite of my SAT solver varisat and writing about the process on my blog. Yesterday I finished the input parsing code and am now working on the clause allocator.


Still tinkering away with Tetra - someone on the community Discord has been using it for a game jam, which is exciting (and a very good source of feedback)! It’s also finally working on Mac, thanks to some very patient people on the issue tracker being my guinea pigs :smiley:

Aside from that, I’ve also been working on a (as of yet untitled) library for generating text, based on the ideas from Improv. Still trying to figure out how to fit something like that into a strongly typed language, but hopefully something fun will come out of it!


I’ve released my first video episode of Rust Simplified - Episode 1 - Pattern Matching . And this week I’ll be preparing the next episode.

I also created a public group on MeWe for the Rust community: https://mewe.com/join/rust . Feel free to join!


Tidying up automated test capability for my game, and perhaps another attempt at rewriting the asset loading. Also, a little bit of fun:

:video_game: When you wanna make a game, but you’re automation engineer :gear::


I have finished the 3rd part of my series of blog posts on writing a mod player in Rust. This part covered audio and threads and finished with playing instruments from the mod file.


I have built regex package commonregex for parsing texts in common contexts. Please review and PRs are welcome here!


My last project failed: I tried to extend my Python Portal with rust libs, but this ended in a frustrating story of “Updating of my python version don’t work with my current or rebuilt rust extension”. After a few thoughts and making a game and some stuff in plain C i decided to rewrite my Portal in plain C. After a good developement state i remembered rust and his GUI Situation.

So i will let the GUI in plain C and will exclude the application parts into rust. First steps is becoming familiar with the FFI to c and find best practices. So i write a lots of tests to check each FFI Situation i need.


I made some progress regarding the Stochastic Progressive Photon Mapping (SPPM) I’m working on, but ran into a huge bottleneck regarding cloning the HaltonSampler many times (each iteration). The C++ code looks like this:

    // Perform _nIterations_ of SPPM integration                                                                                            
    HaltonSampler sampler(nIterations, pixelBounds);                                                                                        
    ProgressReporter progress(2 * nIterations, "Rendering");                                                                                
    for (int iter = 0; iter < nIterations; ++iter) {                                                                                        
        // Generate SPPM visible points                                                                                                     
           ParallelFor2D([&](Point2i tile) {                                                                                               
                MemoryArena &arena = perThreadArenas[ThreadIndex];                                                                          
                // Follow camera paths for _tile_ in image for SPPM                                                                         
                int tileIndex = tile.y * nTiles.x + tile.x;                                                                                 
                std::unique_ptr<Sampler> tileSampler = sampler.Clone(tileIndex);                                                            

Anyway, I managed to write out the first two images rendered by the Rust version, but need to debug, find out why the iterations stop early (by returning from the Render() function), and implement the multi-threaded version of the same code (once it runs through all iterations):

All the details can be found in the first link (issue #86) …


In the HorseShoe crate trying to sort new things that appear while I’m coding.


Im working on next gen text editor called xi-editor. Implemented a way to allow users to tail a file on demand (PR if you are interested). I was surprised to know (you would too!!) how a simple data structure called Rope can create wonders in string manipulations.


I was tinkering with mrustc and cc65 this week, using them to cross compile Rust to the Commodore 64.


I’m working on WebAssembly interpreter from scratch which aimed to run on some micro-controller, and this week it achieved to operate WebAssembly’s bytecode on SMT32F3-Discovery board thanks to Embedded Rust tutorial series.