What's everyone working on this week (20/2017)?


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

What's everyone working on this week (51/2016)?

I’m creating my first crate whose purpose is to allow creating so called type-safe enum mappings based on arrays. Previously this could be done by either using an array (not type safe, as array needs to have correct length and you need to convert enum values to usize and back (which is error-prone, as you may accidentally use wrong enum)) or hash map (which was a relatively expensive data structure compared to arrays).

This works as of now on C style enums with implicit discriminator. I don’t have source code so far, as I’m not home, and source code wasn’t uploaded (but I will try soon).

Example usage (pseudo-code, haven’t tested if it works, but it probably should in actual implementation).

enum Example {

fn main() {
    let mut enum_map = enum_map! {
        Example::A => 1,
        Example::B => 2,
        Example::C => 3,
    enum_map[Example::A] += 3;
    assert_eq!(enum_map[Example::A], 4);
    assert_eq!(enum_map[Example::B], 2);
    assert_eq!(enum_map[Example::C], 3);

Announcing enum-map 0.2

While trying to get alto working on emscripten, I’ve discovered that the provided OpenAL implementation is a bit bare bones, so I’m trying to improve it. There are many documented AL extensions that the underlying webaudio API should theoretically allow it to support, including some environmental effects.


My partial port of the PBRT’s (http://www.pbrt.org) C++ code just started to produce images (via direct lighting).

I’m going to fix a bug to make the simple test scene with two spheres and a ground mesh render correctly for Lambertian diffusse materials. I already know what’s causing the artefacts (black parts on the spheres):

If there’s time left I will implement the glass and mirror materials and find a new test scene for global illumination (probaly the Cornell Box). After that I can start with multi-threading before I dig deeper into path tracing code etc. …


Very cool to follow your progress! I need to get the time to finish the PBRT scene file parser in rustracer so I can move to something more fun…


After a couple busy weeks without much free time I’m planning to get back to the open issues for uom (automatic type-safe zero-cost dimensional analysis). I spent some time this weekend adding a std feature and ensuring tests work with all different feature combinations.

Who would have guessed that calling sqrt on floating point types requires the full std library.


I’m currently investigating what it would take to take to bring my main pet project ProDBG https://github.com/emoon/ProDBG to Rust again. Currently (most) of it is in C++ and Qt because I decided to switch to Qt.

Right now exploring options to make UI creation nice on the Rust side and to allow simple usage of “callbacks” (ie Slots in Qt) from Rust side.

Right now I have a basic button being created on the Rust side using a macro which can hide lots of the underlying stuff on binding to Qt

Plugins also don’t need to link with any Qt which is something I really want to strive for. Right now I’m playing around with https://github.com/pest-parser/pest to create a small API def lang to make it easier to generate the bindings from and only expose the things I need.

We will see how this turns out but it’s looking pretty good right now at least.


Exploring WebAssembly with Rust.
By the way i would likre to see Rust examples in WebAssembly Explorer,

mbebenita/WasmExplorer at GitHub.


Take advantage of vacation, more stuff introduced into my toy-project cicada - a simple unix shell, which is my first Rust project.

Why build it (we have bash, etc)? To learn Rust, for fun, and having a easy/customized shell to hack on to fit my own needs :slight_smile:


Thinking about error handling in tantivy. If anyone here has experience with error-chain, slog or otherwise dealing with errors in a fairly complex Rust lib I’d love to hear from you in that thread :smile:


I’m doing the leg work to get cernan’s dependencies updated such that the project is fully onboard with serde 1.0 I also took the opportunity to restructure the configuration parsing code some while I was at it, since the toml-rs interface changed on me in the jump from 0.2 to 0.4 of that library. Ongoing work is introduce_features.

I also want to pull in elastic-rs to get direct integration with ElasticSearch, where now cernan users are forced to go through AWS Firehose. The library cernan uses to communicate with Firehose is rusoto. Both elastic-rs 0.11 and rusoto 0.24 – the latest versions as of this writing – still depend on serde 0.9. Not sure if that’s going to be a problem but I don’t feel great about it.

Tossing in a new library into cernan’s tree is going to increase build times further. Did some reading over the weekend and discovered that https://github.com/rust-lang/rust/pull/38814 now has a stable tracking issue. With that in place I can optionally include fields in cernan’s configuration structure. Will make a big difference, since most cernan users really only use a few of its features at a time but are on the hook for compiling everything. Testing is a problem, as I note here.


Spending entirely too much time trying to make a joke cargo subcommand more awesome! It’s a way for everyone to celebrate Rust’s birthday for a week (starting on the 15th of May).


Working on a project called mush, a sister project to lichen, which will provide a gui front end and easy way to visualize/edit dialogue graphs. I originally wrote mush long ago with its own custom graph backend and used conrod for ui but the project gathered dust. Recently renewed my interest when I started working on lichen-- and as such I am rewriting mush to use imgui-rs and to target lichen directly.
So far I have a file-opener and node contents viewer, with some basic manipulation of state variables in the interface. Next steps include a node-graph view with connections, a basic visual step-debugger, and of course file saving options.


Hello fellow rustaceans!
I am learning Rust in whatever free time I get from the second-edition of the The Rust Programming Language. I have been following it front to back, and trying to write programs to solve problems I encounter in daily work. Once I read about the containers this week, I am planning to write my first significant program that analyzes execution trace of programs - I hope to eventually generalize this code to analyze any sequence of objects. The “analysis” here is generic term that I use for various experiments that I perform.

I am pretty excited to learn this new language that already makes me think about how data flows through the program, even for the “hello world” program.


Just finished reading the draft of the second edition of the Rust Book. Definitely a recommended read!

A while ago I learned the language by doing and the book is helping me a lot to solidify the concepts.

I have an issue assigned to me in cargo-clippy. Need to get it moving before I go to the GStreamer Hackfest this weekend in Galicia :smiley:


I’m continuing work on an RLS issue, which should get me comfortable with its lower levels. Once I’m done I’ll use that knowledge to implement the borrow visualizer in RLS.