rust.md

Rust language bookmarks

• Rust links

  • The Little Book of Rust Books

  • Learn Rust: A Resource Guide

  • Learn Rust With Entirely Too Many Linked Lists

  • Welcome to Comprehensive Rust

  • Item 3: Avoid matching Option and Result

  • Rust Memory Container Cheat-sheet

    • Ownership Concept Diagram

  • Rust 2020 Roadmap

    • Tracking issue for generic associated types (GAT)
      • tracking issue for "chalkification"
      • Solving the Generalized Streaming Iterator Problem without GATs
      • Generalized Autoref-Based Specialization
        • ICE when using GATs with const generics
      • Allow generic associate types in trait paths
        • WIP Generic associated types in trait paths
          • Generic Associated Types in Trait Paths - Ast part
          • Method for Emulating Higher-Kinded Types in Rust
            • Higher Kinded Types in Rust
      • Monads and GATs in nightly Rust
        • GATs on Nightly!
      • How can I avoid GATs in this code?
        • Trait constraints solver with GAT and recursive types
    • Tracking issue for const generics
      • Splitting the const generics features
      • Tracking Issue for min_const_generics
        • stabilize #![feature(min_const_generics)] in 1.50
          • cycle errors for unevaluated constants in the param env
        • min_const_generics prevents references to concrete Self param
        • Shipping Const Generics in 2020
          • fix unification of const variables
        • Making elementwise operations using const generics more ergonomic? (Possible new trait or FromIterator impl)
        • Implementing ArrayVec Using Const Generics
        • Add section ch19-07 on Const Generics
        • Preserving the programmers ‘Intent’ in Unsafe Rust
          • Question on const-generics
      • Tracking issue for "Lazy normalization"
        • check it tl;dr it works!

        #![feature(const_generics)]
        struct MyVec<T: Sized, const LENGTH: usize> {
            inner_data: [T; LENGTH],
        }
        
        impl<T: Copy, const L: usize> MyVec<T, L> {
            pub fn new(value: T) -> Self {
                MyVec {
                    inner_data: [value; L],
                }
            }
        }
        
        fn main() {
            let _my_vec = MyVec::<f64, 10>::new(4.2);
            println!("_my_vec[0] : {}", _my_vec.inner_data[0])
        } 

      • Tracking Issue for complex generic constants (const_evaluatable_checked)
        • Const well-formedness and const equality
        • Addition does not commute in generic_const_exprs
    • Tracking issue for specialization (RFC 1210)
    • [Analysis / Pre-RFC] Variadic generics in Rust
      • About variadics in Rust
      • [Brainstorming] Use cases for variadic generics

  • Rust Tutorial playlist

    • Rust Structs, Traits and Impl
    • Rust Generics
    • Rust Ownership and Borrowing
    • Rust Lifetimes
      • Additional examples to Rust borrowing/lifetimes topic
    • Rust 3D Graphics in the Browser: Boilerplate Setup and WASM Introduction
    • Rust 3D Graphics in the Browser: 2D Graphics
    • Rust 3D Graphics in the Browser: 3D Graphics

  • Jon Gjengset's playlists

    • Desktop and editor setup for Rust development
    • Crust of Rust: Lifetime Annotations
    • Porting Flamegraph to Rust
      • Flame Graphs
    • Implementing TCP in Rust
      • Implementing TCP in Rust (part 1)
      • Implementing TCP in Rust (part 2)
      • Implementing TCP in Rust (part 3)
    • Advanced topics in Rust
      • The Why, What, and How of Pinning in Rust
    • Java's ConcurrentHashMap in Rust
      • Porting Java's ConcurrentHashMap to Rust (part 1)
      • Porting Java's ConcurrentHashMap to Rust (part 2)
      • Porting Java's ConcurrentHashMap to Rust (part 3)
      • learning-rust-crossbeam-epoch
    • Rust open-source contributions stream

  • Rust for Java Devs

  • Rust deployment

  • Why Rust?

  • The Rust Book

    • An alternative introduction to Rust
    • A Gentle Introduction To Rust
    • 24days of rust

  • rust-learning

    • Building a runtime reflection system for Rust (Part 1: dyn Class)
    • Building a runtime reflection system for Rust (Part 2: dyn Attribute)

  • http://rustbyexample.com/

    • Rust by example

  • Implementing Rosetta Code problems in Rust

  • Small but painful annoyances when writing Rust code

  • [Rust projects]

    • Trending Rust projects
    • Is Rust CI still working?
    • huonw/travis-cargo

  • Awesome Rust: A curated list of awesome Rust code and resources

    • gmp bindings for rust: status: build failing, ranges syntax changed
      • rust-gmp crate
      • fixed repoworking with up-to-date rust
      • ramp - A high-performance multiple-precision arithmetic library
        • ramp github repo
    • BLAS bindings
    • LAPACK bindings
      • Ivan Ukhov
      • OpenBLAS Provider
    • Rayon: A data parallelism library for Rust
      • Neon: Node + Rust = Sparkling Heart
    • FFT libraries and bindings
      • RustFFT = "5.0.0-experimental.1"
        • Released RustFFT 5.0.0-experimental.1: Now faster than FFTW!
        • RustFFT
          • RustDCT
      • crate dft
        • dft docs
      • crate rustfft - 1.0 follows kiss fft
      • crate fftw3 - not complete
      • ndrustfft: n-dimensional real-to-complex FFT and real-to-real DCT
    • see it for FFI bindings: Rust bindings for libpcuid CPU detection and feature extraction library
      • Rust Module std::ptr

  • Awesome documentation links for Rust

  • Rust release milestone predictions

  • Are we yet?

    • Are we (I)DE yet?
    • Are we web yet?
    • dead link : Are we concurrent yet?
    • Are we numeric yet?
      • Making Rust a perfect fit for high-performance computations
    • Are We Stdlib Yet?
    • Are we game yet?
    • Are we learning yet?
      • Scientific Computing
      • Are we yet?
        • Taking ML to production with Rust: a 25x speedup

  • Rust ownership, lifetimes and borrowing

    • Why Rust's ownership/borrowing is hard
    • Explore the ownership system in Rust
    • Rust ownership, the hard way
    • Rust Lifetimes
    • Lifetime Reference
      • official lifetimes doc
      • Aha! Understanding lifetimes in Rust
      • Lifetime elision in struct impl
    • Rust, Lifetimes, and Collections
      • Problem about borrowing: My timer implementation requires a mutable reference to the timer queue
      • Problems with a recursive parser

  • Performance Tips

    • Rust Performance Pitfalls
    • Profiling Rust applications on Linux
    • Intro to rustc's self profiler
    • A Better Rust Profiler
      • Statistics-driven Microbenchmarking in Rust
      • Experimental One-shot Benchmark Framework in Rust
      • perf-event: a Rust interface to Linux performance monitoring
    • Rust vs. C++: Fine-grained Performance

    operf ./target/debug/add_sum_sq -k 4 -n 100
    opannotate --source --assembly > operf.listing

    • Learn Rust the Dangerous Way

      • Why Learn Rust the Dangerous Way?
      • You Can't Write C in Just Any Ol' Language: Learn Rust the Dangerous Way, Part 1
      • References Available Upon Request: Learn Rust the Dangerous Way, Part 2
      • Measure What You Optimize: Learn Rust the Dangerous Way, Part 3
      • A More Perfect Union: Learn Rust the Dangerous Way, Part 4
      • Making Safe Things From Unsafe Parts: Learn Rust the Dangerous Way, Part 5
      • Let The Compiler Do The Work: Learn Rust the Dangerous Way, Part 6

    • cargo subcommand to profile binaries

    • Rust support in Linux perf tool

    • What one must understand to be productive with Rust

    • On pattern matching performance in rust

      • Mixing matching, mutation, and moves in Rust
      • Idiomatic way of testing Result<T, Error>?
        • How to Design For Panic Resilience in Rust

    • Rust Faster!

      • The Computer Language Benchmarks Game: Rust implementations
      • Compile-time type checking for arbitrary unit systems

    • Сравниваем Swift и Rust

    • Which language has the brightest future in replacement of C between D, Go and Rust? And Why? Andrei Alexandrescu, D Language Architect

    • I wrote my Bachelor's thesis about Go and Rust in high-performance computing

      • bachelor's thesis titled "Evaluation of performance and productivity metrics of potential programming languages in the HPC environment"
      • Evaluation of C, Go, and Rust in the HPC environment
      • Evaluation of performance and productivity metrics of potential programming languages in the HPC environment - A comparison of Rust, Go and C -- University of Hamburg
      • Rust programs versus Go by benchmark task performance

    • How to explain slowdown with Sieve of Eratosthenes versus Nim and C?

    • (more or less) accurate floating point algorithms

    • Benchmarking programs in Rust

    • How to zip two slices efficiently

    • How to memcpy bytes in stable rust

      • Stabilizing basic functions on arrays and slices: clone_from_slice

    • Builder pattern without cloning

    • Fearless Concurrency with Rust

    • Rust vs. C++: Fine-grained Performance

    • cargo benchcmp

      • Porting cargo benchcmp

    • Macros in Rust: A tutorial with examples

      • How do I create a Rust macro with optional parameters using repetitions?
      • macro expand
      • Loop unrolling
        • Can I create a macro that unrolls loops?
          • How do I see the expanded macro code that's causing my compile error?
      • Loop unrolling on request

  • Linear Algebra + Numerics

    • faer is a collection of crates that implement low level linear algebra routines in pure Rust

      • faer announcement on reddit

    • Rust Science crates

      • Russell - Rust Scientific Library
      • aegir is an experimental autodifferentiation framework designed to leverage the powerful type-system in Rust and avoid runtime as much as humanly possible
      • argmin is a numerical optimization library written entirely in Rust
      • Arbitrary-Precision Floating-Point Library

    • Mathru crate

      • Mathru Getting started
      • mathru

    • Scientific computing: a Rust adventure [Part 0 - Vectors]

    • Scientific computing: a Rust adventure [Part 1 - Zero-cost abstractions]

    • Eigenvalue Decomposition

    • Scientific computing: a Rust adventure [Part 2 - Array1]

    • Ventifact’s Linear Algebra. A place for learning about and sharing linear algebra.

      • Writing A Linear Algebra Library in Rust, Part I
      • Ventifact's Linear Algebra

    • diffeq

      • diffeq | Lorenz Attractor
      • diffeq - Basic Ordinary Differential Equation solvers

    • Surface reconstruction library and CLI for particle data from SPH simulations

      • numeric_literals

    • FENRIS: A Rust library for building advanced applications with the Finite Element Method (FEM)

    • Scientific Computing in Rust: bacon-sci

      • Scientific Computing in Rust: bacon-sci

    • Rust 2020: Scientific Rust

      • Staggered-Grid Fluid Solver in Rust
      • Weak Galerkin Finite Element Method -- looks promising but very outdated
        • for translation to modern Rust:
          • The Periodic Table of Rust Types: ycombinator
            tl;dr **sigil ~** -> Box
          • The Periodic Table of Rust Types
          • A quick reference of the sigils and their meaning
      • A curated list of Rust code and resources that do NOT exist yet, but would be beneficial to the Rust community.

    • Rust 2019: Beat C++ ?

      • Rust numeric-array
      • Embedded Rust arithmetic, 2D/3D vector, and statistics library

    • Special functions for Rust by binding to the Cephes library

    • Library of well known algorithms for numerical root finding

    • rcpr - Rust Chebyshev Proxy Rootfinder: A robust global rootfinder using adaptive Chebyshev interpolation with automatic subdivision that accurately finds all roots of a smooth function F(x) on [a, b] using the Chebyshev-Frobenius companion matrix

    • funspace - chebyshev

    • Polsim - a case study for small-scale scientific computing in Rust

      • Simulate the polarization of a laser beam
      • A command line utility for doing polarization simulations

    • a collection of Summation By Parts operators which can be used for solving partial differential equations

      • Solving the compressible Euler equations by using the SBP-SAT method

    • FEM_2D: A Rust Package for 2D Finite Element Method Computations with Extensive Support for hp-refinement

      • fem_2d

    • Fast Fluid Dynamics Built with Rust+WASM and WebGL

    • ponyo - A 2D, semi-Lagrangian fluid solver

    • delaunator-rs A very fast static 2D Delaunay triangulation library for Rust. A port of Delaunator

    • Implementation of a 2-dimensional MAC (marker and cell) fluid solver in Rust

    • Delaunay mesh

      • Rust Delaunay Triangulation
      • Rust Discontinuous Galerkin
      • Rust Symbolic Algebraic
        • Computer Algebra System in Rust
      • [Open Rust CFD: A 3D, unstructured computational fluid dynamics (CFD) solver](https://github.com/reidprichard/ORC

    • a list of linear algebra libraries for Rust

    • Numerics & math foundation

    • Solving Sparse Matrix Systems in Rust

      • Sparse multidimensional structures written in Rust
        • ndsparse

    • An extensible HPC-Framework for CUDA, OpenCL and native CPU

    • Extremely generic linear algebra libary for Rust

    • A Linear Algebra library that uses const generics to be no_std and specialization to enable SIMD

    • A Rust linear algebra library based on const generics

    • al-jabr - n-dimensional linear algebra and mathematics library for computer graphics and other applications

    • The all-in-one maths library for Rust : A general purpose mathematics library for Rust, not usable now

    • Request for some numerics related features

      • (former Unum)Create RUST posit arithmetic library based on 21 February 2017 Posit Arithmetic by John L. Gustafson - Beating Floating Point at its Own Game
        • A Rust implementation of the posit number system
      • Pre-RFC: Dealing with broken floating point
      • John Gustafson presents: Beyond Floating Point – Next Generation Computer Arithmetic

    • Multithreaded matrix multiplication in Rust - Part I

    • Multithreaded matrix multiplication in Rust - Part II

      • Anatomy of High-Performance Many-Threaded Matrix Multiplication

    • A gemmed rabbit hole

      • GEMM in Rust implementation

    • Matrix Multiplication in Rust (Part 1)

    • ndarray: an N-dimensional array with array views, multidimensional slicing, and efficient operations

      • ndarray presentation by the author
      • ndarray_for_numpy_users

    • sparse linear algebra library for rust

    • Linear algebra library for the Rust programming language

      • Linear algebra library for Rust

    • Peroxide - Rust numeric library contains linear algebra, numerical analysis, statistics and machine learning tools with R, MATLAB, Python like macros

      • Peroxide github repo

    • A Rust linear algebra library based on expression templates

      • Rust’s operator overloading doesn’t scale

    • Convolutions in Rust for Deep Learning

      • Understanding Convolution in Deep Learning
      • Convolutional Neural Networks

    • UKF written in Rust based on the C++ UKF from the Udacity SD Car Nanodegree

    • Neuronika is a machine learning framework written in pure Rust, built with a focus on ease of use, fast prototyping and performance

    • Arrayfire

      • ArrayFire: a general purpose GPU library. http://arrayfire.com

        • ArrayFire install on Ubuntu
        • ArrayFire convolve1

      • Arrayfire Rust Bindings - is a high performance library for parallel computing with an easy-to-use API

        • Function arrayfire::fft_convolve1
          • a composition of forward fft and inverse ifft operations is not identical to the original vector #51
          • Add code examples to documentation #52

        requisites

        • GLFW

          ldd ./lu_cpu
          ...
          libglfw.so.3 => not found

          • GLFW build apps

          • GLFW github

          git diff -u CMakeLists.txt
          diff --git a/CMakeLists.txt b/CMakeLists.txt
          index aa22cc3..0fb3c0e 100644
          --- a/CMakeLists.txt
          +++ b/CMakeLists.txt
          @@ -18,7 +18,7 @@ set(LIB_SUFFIX "" CACHE STRING "Takes an empty string or 64. Directory where lib
          
           set_property(GLOBAL PROPERTY USE_FOLDERS ON)
          
          -option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
          +option(BUILD_SHARED_LIBS "Build shared libraries" ON)
           option(GLFW_BUILD_EXAMPLES "Build the GLFW example programs" ON)
           option(GLFW_BUILD_TESTS "Build the GLFW test programs" ON)
           option(GLFW_BUILD_DOCS "Build the GLFW documentation" ON)

        • add to .bashrc

        # used to be for ArrayFire
        #export AF_PATH=$HOME/work/arrayfire-3
        #export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$AF_PATH/lib
        # now
        
        # for openblas-provider
        # see [OpenBLAS: Detecting CPU failed during build](https://github.com/JuliaLang/julia/issues/394)
        # symptome: error: ‘SGEMM_DEFAULT_UNROLL_M’ undeclared
        export CARGO_FEATURE_SYSTEM_OPENBLAS=1
        
        # for arrayfire-rust
        export AF_PATH=/usr

        • use ArrayFire

        mkdir build
        pushd build
        cmake -DArrayFire_DIR=$AF_PATH/share/ArrayFire/cmake ..
        make VERBOSE=1

        • arrayfire-project-templates/CMake/CMakeModules/FindOpenCL.cmake

  • async

    • Are we async yet?
    • The What and How of Futures and async/await in Rust
    • Comparison of Rust async and Linux thread context switch time and memory use
    • A practical guide to async in Rust
    • Different levels of async in Rust
    • History and status quo of async/non-blocking I/O in Rust?
      • Add a Client Guide
    • Stateful: A Rust Experimental Syntax Extension for Generators and More
    • Pretty State Machine Patterns in Rust
    • Async IO for Rust (part II)
    • Condition variable not playing well with thread::sleep

  • Rust parser generators

    • nom 1.0 Write Really Fast Parsers
      • nom on github
    • LALRPOP
      • LALRPOP tutorial
    • rusty-peg crate
      • rusty-peg github
    • Parser Combinators: The road to Chomp 0.1
      • A fast monadic-style parser combinator designed to work on stable Rust

  • Announcing Rust 1.0

    • Priorities after 1.0

  • Setting vision for 2017 cycle

    • Rust's 2017 roadmap
    • Associated type constructors (a form of higher-kinded polymorphism)
    • [Roadmap 2017] Productivity: learning curve and expressiveness
    • Roadmap 2017 request - needs of HPC
    • Language ergonomic/learnability improvements
    • Rust Objectives Observation

  • On Rust goals in 2018 and beyond tl;dr rust sucks for numerics

  • IDE для Rust

    • Are we (I)DE yet?

  • rusty-tags : Create ctags/etags for a cargo project and all of its dependencies

  • New Rustacean : http://www.newrustacean.com/show_notes/e008/ : http://www.newrustacean.com/show_notes/e008/

  • Getting into the nitty-gritty with Rust's traits

    • “Subclassing” traits in Rust

  • 'The Rust Programming Language' E-Books'

    • Rust iterators
      • Reddit Rust iterator cheet sheet

  • The Advanced Rust Programming Language

  • Rust For C++ Programmers

    • C++ to Rust - or how to render your mindset
    • blogs: Rust for C++ programmers
    • Arrays and Vectors in Rust
    • On rust's memory management: Mainly for C/C++ programmers
    • Why not just add classes?
      • Composition over inheritance
    • Today I learned — episode 3 (strong typing in C++ vs. Rust)

  • Rust patterns

    • Common data structures and algorithms in Rust
    • A catalogue of Rust design patterns
    • Rust Patterns: Using traits for function overloading
      • rust-modifier: emulates overloading
    • Dependency Injection in Rust
    • Dependency injection container - Learning the ropes in Rust
    • Rust's flawed dynamic type
      • chris-morgan/mopa
    • Mixing matching, mutation, and moves in Rust
    • Polymorphism in Rust: Enum vs Trait + Struct
      • Recursive Enum Types
      • How to use C++ polymorphism in Rust
    • Implementing an object factory pattern in Rust using closures
    • Typestates in Rust
      • CS 242: Programming Languages, Fall 2019
        • Graphs: All Foundational Methods
        • Word Level Parallelism

  • Rust concurrency

    • Rust Atomics and Locks
      • This repository contains the code examples, data structures, and links from Rust Atomics and Locks
      • Mara's Blog
        • Comparing Rust's and C++'s Concurrency Library
    • Gregory Terzian
      • Rust concurrency: the archetype of a message-passing bug.
      • Rust concurrency: five easy pieces.
      • Further thoughts on async/await.
      • Rust concurrency patterns: condvars and locks
    • Comparing parallel Rust and C++
      • Performance comparison of parallel Rust and C++
    • Concurrent Programming in Rust course EECS 3/495
    • An Adventure in API Design and Concurrency in Rust
      • Concurrency in Rust: vimeo video
    • Lock free stack
      • Lock free stack on github
      • AtomicPtr with stamp to avoid ABA problem
      • AtomicU128 for x86_64
    • Learn Rust: Dining Philosophers runs not concurrent
    • parry - Parallel array processing: deflect performance problems
    • crossbeam - Support for parallelism and low-level concurrency in Rust

  • Pros and cons: Rust vs. C++

    • Rust: A Scala Engineer's Perspective
    • Rust and the Blub Paradox
      • You can't spell trust without Rust
      • twitter You can't spell trust without Rust
    • cpp_to_rust
    • What are the problems that Rust solves for you?
      • Simple N-Body with LeapFrog integrator

  • Books, Docs: generation, in Russian, vs. C++

    • mpankov ООП на Rust
    • mpankov rust-crash-course
    • Rust Books List
    • Rust for C++ Programmers
    • Rust Programming Step-by-Step
    • Convert The Rust Programming Language to Epub
    • The Rust Programming Language (на русском)
    • Rust for clojurists
    • Язык программирования Rust и первые впечатления от него (17 ноября 2014)
      • Десять веских причин не тащить в продакшн новые игрушки
      • Criticizing the Rust Language, and Why C/C++ Will Never Die

  • epsilonz - Functional Programming in Rust

  • Abstracted Algebra in Rust, or, Why Rust is better than C++, part I

    • More Abstracted Algebra in Rust, or Does 'Group' distribute over 'Ring'?

  • Graphs in Rust

    • Graphs and arena allocation

  • A library of mesh generation utilities

  • rust on habrahabr

    • Многопоточность в Rust
    • Создание функции на Rust, которая возвращает String или &str
    • Куча способов переиспользовать код в Rust

  • Adam Leventhal's blog: First Rust Program Pain (So you can avoid it...)

  • LLVM изнутри: как это работает

  • Thorin/Impala paper: A Graph-Based Higher-Order Intermediate Representation

  • unicode chars for idents

  • Misc

    • Why does serde_json::to_writer not require its argument to be mut?

    • Implementing Finite Automata (Part 1)

    • Contributing to Rust

    • Interview with Mozilla’s Aaron Turon

    • julia vs. rust

    • Rust library for opening and working with dynamic link libraries

    • Higher kinded polymorphism #324

      • Higher-kinded types #1185
        • implement higher-order unification for type constructor inference
      • What languages other than Haskell support higher kinded types?

    • Rust, дисциплинирующий язык программирования

      • Основы Rust – Глава 2. Использование переменных и типов
      • Обработка ошибок в Rust
      • Сопоставление с образцом, изменения и перемещения в Rust
      • Сравнение производительности языков на примере простейшего классификатора
      • Заимствование и время существования в Rust
      • Создаём REST-сервис на PostgreSQL и Rust. Часть 1: прототип
      • Создаём REST-сервис на Rust. Часть 2: читаем INI; multirust
      • Создаём REST-сервис на Rust. Часть 3: обновляем базу из консоли
      • Создаём REST-сервис на Rust. Часть 4: переходим к REST API
      • Создаём REST-сервис на Rust. Часть 5: обработчики, рефакторинг, и макросы
      • Rust в деталях: пишем масштабируемый чат с нуля, часть 1

    • Good Practices for Writing Rust Libraries

    • Porting to Rust

      • C to Rust transpiler, based on cparser
      • Type-Safe Unions in C++ and Rust
        • Beyond Memory Safety With Types
      • The Arduous Journey of Porting C to Rust
      • Baby Steps: Slowly Porting musl to Rust
      • That's so Rusty!: Smart pointers
      • That's so Rusty! Fearless concurrency
      • Dancing Links In Rust

    • Iterator trait

      • iota editor written in Rust; use case for idiomatic iterator usage

    • Can't find crate for num

    • Multiple binaries in Cargo

    • Rosetta code for complex in Rust

    • RustType is a pure Rust alternative to libraries like FreeType

    • Raw Pointers

      • Primitive Type pointer
      • Dereferencing untyped raw pointer
      • Rust FFI and Opaque pointer idiom

    • Reading binary file

    use std::fs::File;
    use std::io::Read;
    
    fn main()
    {
        let mut file=File::open("Cargo.toml").unwrap();
        let mut buf=[0u8;12];
        file.read(&mut buf).unwrap();
        println!("{:?}",buf);
        // use file
    }

    • Generics, Arrays and Cloning

    • Tricks with ownership in Rust

    • Effectively Using Iterators In Rust

      • What is the difference between iter and into_iter? tl;dr

      let vec1 = vec![1, 2, 3];
      let vec2 = vec![4, 5, 6];
      
      // `iter()` for vecs yields `&i32`. Destructure to `i32`.
      println!("2 in vec1: {}", vec1.iter()     .any(|&x| x == 2));
      // `into_iter()` for vecs yields `i32`. No destructuring required.
      println!("2 in vec2: {}", vec2.into_iter().any(| x| x == 2));

    • Initialize an array with a closure

    • Inheritance, why is bad?

    • deprecated OOP inheritance adapted to Rust

      • Usecases for inheritance
        • Rust type system and the Circle-ellipse problem
      • Abstraction without overhead: traits in Rust
        • Most coveted Rust features

    • confusing error "ambiguous associated type" on missing enum variants

      • How do I disambiguate associated types?

    • Announcing Alacritty, a GPU-accelerated terminal emulator

  • Useful tips

    • Rust after the honeymoon

    • Use VIM as your RUST IDE

    • Read a file line by line

    • Rust Tips and Tricks

    • Using rustfmt in Vim

    # for cargo
    export CARGO_HOME=$HOME/.cargo
    export RUST_SRC_PATH=$HOME/work/github/rust/src
    export PATH=$CARGO_HOME/bin:$PATH

    cargo install --git 'https://github.com/phildawes/racer.git'
    cargo install --git https://github.com/nrc/rustfmt
    echo 'pub fn main(){println!("hello");}' | rustfmt

    pub fn main() {
        println!("hello");
    }

    • Vim Racer Plugin

    • Racer progress update Dec 29, 2015

    • A bunch of lints to catch common mistakes and improve your Rust code

    • Convert string slice to int in rust

    • Learning to 'try!' things in Rust

      • try!

    • How do I sum a vector using fold?

    • How do you import macros in submodules in Rust? tl;dr

    an `extern crate` loading macros must be at the crate root

    put the #[macro_use] extern crate serde_derive; in the crate root, which is main.rs and/or lib.rs

    • Lifetime error when creating a function that returns a value implementing serde::Deserialize

    • Using serde's deserialize_with to handle custom strings

    • How to unit-test a deserialization function used in serde(deserialize_with)?

    • Closures don’t move Copy types by default?

  • Misc.

    • Converting from Option to Option<&str>

    • Rust and Default Parameters

    • Dual numbers in Rust

    • libfloat

    • A vantage-point tree implementation backed by vectors for good performance with no unsafe code

    • [Announcement] ArrayDeque: Deque (ring buffer) on stack!

    • Grouping structs with enums

      • Proc macro crate for working with newtype enums: FromVariants tl;dr

      //! Example
      #![warn(missing_docs)]
      
      #[macro_use]
      extern crate from_variants;
      
      /// A sample struct.
      #[derive(Debug, Clone, FromVariants)]
      pub enum Lorem {
          /// Hello world
          #[from_variants(skip)]
          Str(String),
          
          /// Hello world
          Num(u16),
      }
      
      fn main() {
          println!("{:?}", Lorem::from(10));
      }

      generated

      #[doc = "Convert into a `Num` variant."]
      impl ::std::convert::From<u16> for Lorem {
          fn from(v: u16) -> Self {
              Lorem::Num(v)
          }
      }

    • Rustdoc: reStructuredText vs Markdown: On The Potential Inadequacy of Markdown

    • How to implement a C union in Rust

    • Implementation of Software transactional memory

    • Basic wrapper around libVEX from Valgrind

    • Rust implementation of the Quine-McCluskey

    • cargo-tree produces

    $ cargo tree
    chrono v0.2.17 (file:///Volumes/git/rust/rust-chrono)
    ├── num v0.1.29
    │  ├── rand v0.3.12
    │  │  ├── advapi32-sys v0.1.2
    │  │  │  ├── winapi v0.2.5
    │  │  │  └── winapi-build v0.1.1
    │  │  ├── libc v0.2.4
    │  │  └── winapi v0.2.5 (*)
    │  └── rustc-serialize v0.3.16
    ├── rustc-serialize v0.3.16 (*)
    ├── serde v0.6.6
    │  └── num v0.1.29 (*)
    ├── serde_json v0.6.0
    │  ├── num v0.1.29 (*)
    │  └── serde v0.6.6 (*)
    └── time v0.1.34
       ├── kernel32-sys v0.2.1
       │  ├── winapi v0.2.5 (*)
       │  └── winapi-build v0.1.1 (*)
       ├── libc v0.2.4 (*)
       └── winapi v0.2.5 (*)

    • Rust task runner and build tool

    • Parse command line argument by defining a struct

      • How to Build CLIs in Rust with StructOpt
      • Manual for structopt library

    • Rust and Rest

      • Rust bindings to libcurl

    • Accumulator factory Rust

    use std::ops::Add;
     
    fn foo<Num>(n: Num) -> Box<FnMut(Num) -> Num>
            where Num: Add<Output=Num> + Copy + 'static {
        let mut acc = n;
        Box::new(move |i: Num| {
            acc = acc + i;
            acc
        })
    }
     
    fn main() {
        let mut x = foo(1.);
        x(5.);
        foo(3.);
        println!("{}", x(2.3));
    }

    • Accumulator factory C++, see esp. C++11

    • Why the [u8] inside Box<[u8]> does not implement AsRef<[u8]> + AsMut<[u8]>? + Why does T implement A+B but not trait C: A+B?

    • Working around the lack of associated method on parametric traits?

    • cpp-templates-vs-rust-generics

    • Rust, Generics, and Collections

      • Generics and Compile-Time in Rust

    • Matching, saving and replacing text with the regex crate

  • Ideas, RFCs, that are not in the language yet

    • HKT
      • What Are Sum, Product, and Pi Types?
      • Rust/Haskell: Higher-Kinded Types (HKT)
        • Higher-kinded type trait
        • Does/Will Rust support functional programming idioms?
      • Blog post series: Alternative type constructors and HKT
        • Associated type constructors, part 1: basic concepts and introduction
        • Associated type constructors, part 2: family traits
        • Associated type constructors, part 3: What higher-kinded types might look like
        • Associated type constructors, part 4: Unifying ATC and HKT
      • Pi types v2 (const generics)
        • [lang-team-minutes] Const generics
          • new Const generics RFC
        • with-bounds-in-pi-types
        • RFC: Constant generics (restricted Π types) for Rust, core RFC (v2)
          • Generics over the size of an array type (in anticipation of const generics)
            • generic-array
          • Associated Consts
            • Associated constant doesn’t exist?
              • associated-constants can not be used in constant expressions
            • Generic associated consts can't currently be used to parameterize fixed array lengths tl;dr it works!

            #![feature(associated_consts)]
            
            trait Const {
                const VALUE: usize;
            }
            
            struct Foo;
            
            impl Const for Foo {
                const VALUE: usize = 4;
            }
            
            fn test(x: [u8; Foo::VALUE]) {
                for _ in x.iter() {
                    println!("hello");
                }
            }
            
            fn main() {
                let x = [1,2,3,4];
                test(x);
            }

      • Dissertation on Algebraic Subtyping
      • Higher-kinded type trait
      • GitHub Gist for HKT
      • Rust and the Monad trait - Not just higher kinded types
      • Reddit: Rust and the Monad trait - Not just higher kinded types
      • Higher Kinded Types
      • Does rust really need higher kinded types?
        • High Order Function with Type Parameter
        • Design patterns for composability with traits (i.e. typeclasses)?
    • step_by on negative numbers
    • GPU support

  • Unable to create a polymorphic type because the trait cannot be made into an object

  • Add LaTeX support to Rustdoc

    • Crate katex_doc
      • katex_doc
    • horrible-katex-hack
    • rustdoc-katex-demo
      • KaTeX for documentation
        • Struct hmmm::HMM
    • Add Mathjax (KaTeX?) Support to Rustdoc #16300
    • Add mathematics support to rustdoc #17390
    • Rustdoc: reStructuredText vs Markdown
    • Embedding LaTeX in Rust documentation?
      • Snekdown - More than just Markdown
        • Snekdown - More than just Markdown
          • Snekdown docs
          • AsciiMath
      • Minimal Rust project example for using Latex in docs
      • The Tectonic Typesetting System
        • Rewriting LaTeX in Pure Rust
        • Porting all of Tectonic (modern TeX/LaTeX engine) from C to Rust
          • Rust port of Tectonic
      • ReX - typesetting mathematics
        • ReTeX - Typesetting mathematics
        • modern up-to-date fork of ReX - typesetting mathematics
      • Extending the Literate Programming Tool Tango
        • Markdown-based Literate programming in Rust, integrated with Cargo
          • Demonstration crate for the tango literate programming tool
        • md sample for literate programming in Rust with tango
          • Increasing Rust’s Reach
    • mdBook
      • Scientific mdbook plugin
        • The Rust Machine Learning Book

  • GC in Rust

    • GC and Rust Part 0: Garbage Collection Background
    • GC and Rust Part 1: Specifying the Problem
    • GC and Rust Part 2: The Roots of the Problem

  • Machine Learning in Rust

    • linfa aims to provide a comprehensive toolkit to build Machine Learning applications with Rust
    • A linear algebra library in Rust designed for machine learning
    • Linear Algebra in Rust
    • rustlearn - A machine learning package for Rust
    • autograph - Machine Learning Library for Rust
      • AMD / ROCm support for autograph
    • Nengo RS is an experimental Nengo backend written in Rust
      • The Nengo Brain Maker is a Python package for building, testing, and deploying neural networks
    • tch-rs : Rust bindings for the C++ api of PyTorch

  • The Kolmogorov-Smirnov Test

    • Implementation of the Kolmogorov-Smirnov statistical test as a Rust library

  • rand : A Rust library for random number generators and other randomness functionality.

  • A library for differential-geometric calculations

    • A Rust crate for differential-geometric calculations
    • Differential geometry in Rust
      • Possible bug in trait bounds evaluation #30262

  • A native-rust implementation of an Effect monad, inspired by PureScript's EFF Monad

  • pijul - distributed version control system written in Rust

    • Commutation and scalability in pijul, the new version control system written in Rust
    • Add Pijul support to Cargo
    • Pijul: Sane Version Control (Pierre Étienne Meunier)
    • Announcing Pijul 1.0 beta, a Version Control System written in rust
      tl;dr

    cargo install pijul --version "~1.0.0-beta" --features git

    • How to convert git to pijul repositories?

  • Recycle - ergonomic allocated memory reusing.

  • Hardware (bare metal) - OSes, ISA simulators,etc.

    • DBus

      • DBus projects in Rust
      • A D-Bus binding for Rust
        • dbus-rs: Serde support for msgarg
      • dbus-rs/src/message.rs
      • argument_guide
      • Struct dbus::arg::Iter tl;dr

      struct ServiceBrowserItemNew {
          interface: i32,
          protocol: i32,
          name: String,
          item_type: String,
          domain: String,
          flags: u32,
      }
      
      fn service_browser_item_new_msg(m: &Message) -> Result<ServiceBrowserItemNew, TypeMismatchError> {
          let mut iter = m.iter_init();
          Ok(ServiceBrowserItemNew {
              interface: try!(iter.read()),
              protocol: try!(iter.read()),
              name: try!(iter.read()),
              item_type: try!(iter.read()),
              domain: try!(iter.read()),
              flags: try!(iter.read()),
          })
      }

      • D-Bus Desktop Notification using dbus-rs
        • Send Desktop Notifications on linux and bsd
          • Handpicked Rusty Crates

    • Writing an OS in Rust

      • Introduction to Paging
      • Paging Implementation
      • Async/Await

    • A comparison of operating systems written in Rust

      • Writing a Linux-compatible kernel in Rust
        • Kerla is a monolithic operating system kernel from scratch in Rust which aims to be compatible with the Linux ABI
        • Resea [ríːseə] is a microkernel-based operating system written from scratch
        • Kazari - A no_std GUI software stack
        • nsh
      • Redox: A Rust Operating System
        • github redox os
          • This Week in Redox 5
          • Sodium: Vim 2.0
            • the Redox editor now is here
          • Redox is Serious
          • ion-shell
            • redox-os/ion
          • The Orbital Widget Toolkit
      • Theseus: an Experiment in Operating System Structure and State Management + Theseus: an Experiment in Operating System Structure and State Management: slides + OSDI '20 - Theseus: an experiment in operating system structure and state management + Theseus OS: OSDI 2020 Long Talk
        • Theseus: Rethinking Operating Systems Structure and State Management
          • PhD Defense -- Theseus: Rethinking OS Structure and State Management
        • Theseus: A modern experimental OS written from scratch in Rust
        • Theseus is Hiring!
          • [Introduction to Theseus](https://www.theseus-os.com/Theseus/book/index.html
          • Theseus OS
      • MOROS: Obscure Rust Operating System
        • Writing a file system from scratch in Rust
        • Writing a file system from scratch in Rust

    • rustv - A minimal, intentionally inaccurate RISC-V ISA simulator

      • about RISC-V and Rocket processor see The RISC-V Instruction Set Architecture
      • see also Chisel - Constructing Hardware in a Scala Embedded Language
      • Building a RISC-V simulator in Rust - Part 1
      • R2VM is the Rust for RISC-V Virtual Machine.
        • Accelerate Cycle-Level Full-System Simulation of Multi-Core RISC-V Systems with Binary Translation
        • Muntjac is a minimal 64-bit RISC-V multicore processor that's easy to understand, verify, and extend.
        • Spike RISC-V ISA Simulator
        • Parallax Static Timing Analyzer

    • Grover: Why Rust for Low-level Linux programming?

    • CLOCK-Pro: An Effective Improvement of the CLOCK Replacement

    • Writing Bare-metal Rust Applications with no_std

  • Formal Verification

    • rsmt2
      • rsmt2 github
    • Synthesizing Loop-Free Programs with Rust and Z3
      • Synthesis of Loop-free Programs in Rust
    • Simple verification of Rust programs via functional purification
      • LEAN
      • Theorem Proving in Lean
    • A Formal Verification of Rust's Binary Search Implementation
    • GitHub - Kha/electrolysis: Simple verification of Rust programs via functional purification
    • Electrolysis Reference
    • Status of Rust Code Analyzers
      • Thesis: Simple Verification of Rust Programs via Functional Purification
    • Pre-RFC: Extending where clauses with limited formal verification

  • C & C++ projects being converted to Rust

    • Physically Based Rendering

      • Rust crate to implement at least parts of the PBRT book's C++ code
      • Release Notes for rs PBRT
        • from here

    • Think Bayes

      • a unofficial rewrite of Allen B. Downey's ThinkBayes in to Rust

    • Algorithms and Concepts from Stepanov's "Elements of Programming"

      • Algorithms and Concepts from Stepanov's "Elements of Programming" implemented in Rust

    • Editors

      • Build Your Text Editor With Rust!
      • Helix
        • Helix - A post-modern text editor
        • Helix docs
        • Lapce - Lightning-fast And Powerful Code Editor
          • Plugin: C/C++ (clangd) No such file or directory (os error 44)
      • A community-driven port of Emacs to Rust
      • Aspiring vim-like text editor
      • No Nonsense Neovim Client in Rust
      • A complete text editor for your terminal.
        • The Bram Moole-Laaw: There Will be Attempts to Rewrite Vim in Nearly Every New Language

    • How I Wrote a Modern C++ Library in Rust

    • Rewritten in Rust: Modern Alternatives of Command-Line Tools

      • Text search-and-replace & Find (grep-like tools)
        • amber (written in Rust - a good starting point)
        • ripgrep is faster than {grep, ag, git grep, ucg, pt, sift}
        • A simple, fast and user-friendly alternative to 'find'

    • [Share] Rust 14 CLI tools

      • 14 Rust Tools for Linux Terminal Dwellers

    • Awesome Rewrite It In Rust - A curated list of replacements for existing software written in Rust

      • uutils coreutils rewrite in Rust
      • SAD! -Space Age seD
      • broot - get an overview of a directory, even a big one
      • FClones — Efficient Duplicate File Finder and Remover

  • Video

    • warming up: Even more general pixels
    • imgref: A trivial Rust struct for interchange of pixel buffers with width, height & stride
    • resize: Simple resampling library in pure Rust

  • Linux distros Rust support

    • Fedora to support Rust Compiler
    • Rust crates for packaging systems
      • A cargo subcommand that generates Debian packages from information in Cargo.toml
        • Announcing Cargo Deb
      • cargo-arch - generate Arch Linux packages from information in Cargo.toml

  • Run Rust code on your NVIDIA GPU

    • Rust nvptx
    • NVPTX backend metabug
    • Utilize GPU computational capabilities
    • PTX support, take 2
    • Tracking issue for the "ptx-kernel" ABI

  • Rust & CUDA OpenCL

    • State of GPGPU in 2022
      • rust-gpu
      • Announcing The Rust CUDA Project; An ecosystem of crates and tools for writing and executing extremely fast GPU code fully in Rust
      • The Rust CUDA Project
        • Getting Started
      • opencl3
    • rust-gpu
    • Пишем на Rust + CUDA C
    • Accel: GPGPU Framework for Rust
    • My Rust 2021 roadmap
    • RustiCL
    • Rust opencl3
      • Crate opencl3

  • diagrams using Rust

    • SvgBobRus is an ascii to svg converter tl;dr

    cargo install svgbob_cli
    svgbob < examples/long.bob > long.svg
    svgbob -o long.svg < examples/long.bob
    svgbob examples/long.bob > long.svg

    • Drawing SVG Graphs with Rust
    • resvg is an SVG rendering library

  • Graphics in Rust

    • Rust Graphics Crates

    • librsvg - A small library to render Scalable Vector Graphics (SVG), associated with the GNOME Project

      • libRSVG bindings for Rust
      • Federico's Blog on librsvg

    • Rust Graphics Mages

      • Awesome wgpu
      • Native WebGPU implementation based on gfx-hal
      • Rust bindings to wgpu native library
      • Universal shader translation in Rust
      • Graham scan from Algorithms in a Nutshell in Rust
      • Plexus is a Rust library for 2D and 3D mesh processing
        • entry point for quad-edge implementation in Rust
        • The quad-edge data structure (Delaunay/Voronoi)
      • Vulkan bindings in Rust
        • Ash - A very lightweight wrapper around Vulkan
        • erupt - Vulkan API bindings
        • Vulkano is a Rust wrapper around the Vulkan graphics API
        • Work-in-progress software-rendering Vulkan implementation
      • A low-overhead Vulkan-like GPU API for Rust
        • N-Body-Simulation
          • Rust Galaxy Simulator with GPU acceleration powered by wgpu
          • LBM fluid simulation based on wgpu-rs
        • Nannou Update - WebGPU, capturing frames and more!
        • Announcing salva2d and salva3d: fluid simulation in Rust
          • 2D and 3D fluid simulation engine
            • 2D WASM version
            • 3D WASM version
            • This month in rustsim #8 (August − September - October 2019)
              • 2 and 3-dimensional fluid simulation library in Rust.

    • Relm the idiomatic GUI library for Rust

    • A Guide to Rust Graphics Libraries

      • winit - Cross-platform window creation and management in Rust
      • KAS, the toolKit Abstraction System, is a general-purpose GUI toolkit

    • Rust and OpenGL from scratch

      • Rust and OpenGL from scratch - Setup

      • Rust and OpenGL from scratch - Window

      • Rust and OpenGL from scratch - OpenGL Context

      • Rust and OpenGL from scratch - Compiling Shaders

      • Rust and OpenGL from scratch - Triangle

      • Rust and OpenGL from scratch - Colored Triangle

      • Rust and OpenGL from scratch - GL Generator

      • Rust and OpenGL from scratch - Basic Resources

      • Rust and OpenGL from scratch - Failure

      • Пишем свой упрощенный OpenGL на Rust — часть 1 (рисуем линию)

      • Пишем свой упрощенный OpenGL на Rust — часть 2 (проволочный рендер)

      • Пишем свой упрощенный OpenGL на Rust — часть 3 (растеризатор)

      • Simple ray tracer written in Rust from scratch

      • rpt - a physically based, CPU-only rendering engine written in Rust

        • a compound of five cubes, one of the five regular polyhedral compounds

      • A Rust guide to Raytracing in One Weekend by Peter Shirley

        • C++ to Rust - or how to render your mindset
        • C++ to Rust introduction with practical "Raytracing in One Weekend" project
        • Ray Tracing in One Weekend
          • Ray tracing in one weekend : several languages

    • Vision Cortex - Semantic Computer Vision

      • visioncortex VTracer

  • Rust Computer Vision CV

    • Dedicated to making photogrammetry and computer vision easier than OpenCV and faster than C++ (one day)
      • Rust computer vision core crate
      • Implements the eight-point algorithm for estimating the essential matrix
      • Essential matrix estimation from 5 normalized image coordinate correspondences from the paper "Recent developments on direct relative orientation"

  • Rust robotics

    • rust-robotics-libraries

    • Rusty robots Programming a self-balancing robot in Rust

    • adventures-in-motion-control

      • Geometric Constraint Solvers Part 1: Algebraic Expressions

    • ROS stands for Robot Operating System

      • Awesome Rust for Robotics
      • Urdf-viz: URDF file viewer tl;dr links to + kinematics + urdf loader + visualizer + rrt + OTL repositories in Rust
      • adnanademovic repositories
        • Pure Rust implementation of a ROS client library
        • A pure Rust implementation of xml-rpc
        • Serde ROSMSG

    • Learning embedded Rust by building RISC-V-powered robot

      • Part 1
      • Part 2
      • Part 3
      • Part 4

  • WIP : Selected RFCs

    • RFC 1598: generic associated types

      • Tracking issue for generic associated types (GAT)
        • Coherence in Chalk By Sunjay Varma
          • Coherence in Chalk by Sunjay Varma
            • Ignore overflow when finding auto-trait impls in Rustdoc
              • Upgrade Chalk
                • Unify region variables when projecting associated types
                  • convert higher ranked Predicates to PredicateKind::ForAll
      • Generic associated types RFC was merged!
      • Generic associated types (AKA ACT, AKA HKT) RFC merged!

    • RFC 2000: const generics

      • Tracking issue for const generics (RFC 2000)
        • WIP The Genesis of Generic Germination
          • To summarise, this PR is being split out into smaller ones:
            • Add const generics to the AST
            • Add const generics to the HIR
            • Refactor generic parameter encoder functions
            • Add const generics to ty (and transitive dependencies)
              • Add const generics to infer (and transitive dependencies)
              • typeck: Fix const generic in repeat param ICE
              • rustc/rustc_mir: Implement RFC 2203.
                • Add IntoIterator impl for arrays by value (for [T; N])
                • Canonicalize inputs to const eval where needed
                • Lazy normalization of constants
      • generic-array : in anticipation of const generics tl;dr generic-array defines a new trait ArrayLength<T> and a struct GenericArray<T, N: ArrayLength<T>>, which let the above be implemented as:

      struct Foo<N: ArrayLength<i32>> {
      	data: GenericArray<i32, N>
      }

    • RFC 1210: impl specialization

      • Implement RFC 1210: impl specialization #30652

      • Specialize to reuse

      • Shipping specialization: a story of soundness

        • Shipping specialization: a story of soundness

      • Specialization/Inheritance

      • Specialization Tree

      • Conditional Trait Implementations

        • Rust: Conditional Trait Implementation

    • RFC 1422: pub_restricted

    • Upcoming Rust syntax changes #234

      • Generic Associated Types Parsing #45904
      • Update AST to hold const generics #227
        • Generics refactoring (groundwork for const generics)

  • Secure and fast microVMs for serverless computing

  • Writing BPF code in Rust

    • Writing eBPF tracing tools in Rust
    • PoC: compiling to eBPF from Rust
    • Rust virtual machine and JIT compiler for eBPF programs

  • embedded Rust

    • Cross compile for ARM
      • Everything you need to know about cross compiling Rust programs!
      • Cross compiling Rust for ARM (e.g. Raspberry Pi) using any OS!
      • “Zero setup” cross compilation and “cross testing” of Rust crates
      • Operating System development tutorials in Rust on the Raspberry Pi
    • Real Time For the Masses
      • Real Time For the Masses: Organization for the RTFM scheduler and ecosystem
    • Rust Embedded. Разработка под процессоры Cortex-M3 на примере отладочной платы STM32F103C8T6 (Black Pill)
    • (unofficial) Embedded Rust HAL Guidelines
    • Tock is an embedded operating system designed for running multiple concurrent, mutually distrustful applications on Cortex-M and RISC-V based embedded platforms
    • Bobbin is an open-source, cross-platform, vendor-independent development system for embedded programming in the Rust programming language

  • misc

    • Awesome Space

    • Object-Orientation in Rust

      • Object-Oriented Programming in Rust

    • This is a collection of implementations of algorithms and data structures in Rust language

    • How do I convert a Vec to Vec<&str>?

    • Is there any way to get the address of a struct in Rust?

      • A sampling CPU profiler for Linux similar to perf
      • gimli
        • Switching the backtrace crate to using object
          • WIP: Switch from goblin to object
          • How do I use goblin's Elf::parse with a temporary variable?
        • cpp_demangle: a C++ linker symbol demangler
        • A DWARF unwinder based on gimli tl;dr

        let text = AddrRange {
            start: &__text_start as *const _ as u64,
            end: &__text_end as *const _ as u64,
        };
        let eh_frame_hdr = AddrRange {
            start: &__ehframehdr_start as *const _ as u64,
            end: &__ehframehdr_end as *const _ as u64,
        };
        let eh_frame_end = &__ehframe_end as *const _ as u64;

    • Logic in Rust

      • SAT solver written in Rust
        • Varisat
      • Stevia - Satisfiability Modulo Theories (SMT) Solver
        • A Satisfiability Modulo Theories (SMT) solver for the theories of fixed-size bit-vectors, arrays and uninterpreted functions
          • Boolector
      • A modern Prolog implementation written mostly in Rust

    • Rust and WebAssembly

      • Rust, WebAssembly, and the future of Serverless
      • BxJS - Building wasm markdown renderer with Rust
      • sunglasses Curated list of awesome things regarding WebAssembly (wasm) ecosystem
      • PGA Axioms
      • FPS Counter

    • The best Rust frameworks to check out in 2019

      • Actix-rs - rust's powerful actor system and most fun web framework
      • Azul - A free, functional, immediate-mode GUI framework for rapid development of desktop applications written in Rust, supported by the Mozilla WebRender rendering engine.

    • Rust Tutorial on YouTube

    • The If Works

      • A little polymorphism, part 2: channels, combinators and const generics

    • Rust high performance xml reader and writer

    • Prior work on Krylov subspace methods?

    • Herb Sutter: “Metaclasses: Thoughts on generative C++”

    • x-post How do I integrate Rust into other projects?

    • Sometimes you just want to count something globally, and you really dont want to worry to much about data races, other race conditions, all the fun stuff.

    • Rust новости #5 (январь 2019)

    • triangle mesh data structure including basic operations

    • The fastest and safest AV1 encoder. in Rust

    • Is there a time I should use C++ instead of Rust?

    • Speedy Desktop Apps With GTK and Rust

      • nora codes

    • Nannou Update - Vulkan, LASERs and more!

    • Rust with Visual Studio Code: A simple how-to

    • Visual Embedded Rust Programming with Visual Studio Code

    • Return-type based dispatch

    • Configure neovim for rust development

    • cargo ssl download error behind proxy on windows
      tl;dr

    git clone --bare https://github.com/rust-lang/crates.io-index.git

    • Языковое замещение, или Почему Rust сменяет C
      • Operating System development tutorials in Rust on the Raspberry Pi
    • Zero To Production #1: Setup - Toolchain, IDEs, CI
    • Zero To Production #2: Learn By Building An Email Newsletter
      • 3K, 60fps, 130ms: achieving it with Rust
    • The Rust Compilation Model Calamity
    • Generics and Compile-Time in Rust
    • Automatic Differentiation/Differential Programming Support
      • Reverse-mode automatic differentiation: a tutorial
    • Do the compilers really create more optimal code for Rust than for C/C++?
    • Get next n items from an iterator with const generics
    • FFI
      • How to expose a Rust Vec<T> to FFI?
      • Introducting Safer FFI
      • Deriving ReprC for custom enums
      • Complex data types and the Rust FFI
      • CXX — safe FFI between Rust and C++
    • clap
      • clap::_derive::_tutorial
      • Clap: is it possible to have options with multiple values rather than multiple repeats? tl;dr

      /// Dissassemble given sections
      #[arg(short, long, num_args(1..))] // at least one section, such as .text
      disasm: Option<Vec<String>>,

      • clap_derive: Vec/Option behavior is inconsistent with other types

• Rust for Data-Intensive Computation

  • Timely Dataflow
  • Differential Dataflow

• An introduction to Data Oriented Design with Rust

• Rust serialization: What’s ready for production today?

• Rust Persistent Data Structures

• Attempt at quad tree

• I want to implement add trait for a struct which imlpements Fn trait

  • Structure and Interpretation of Classical Mechanics
  • Structure and Interpretation of Classical Mechanics: org mode
  • Structure and Interpretation of Classical Mechanics: pdf
  • SICM: Executable books

• An HDL embedded in Rust

  • Q: Rust as a hardware description language to be synthesized on an FPGA?
  • LLHD
    • Fabian Schuiki
    • LLHD: A Multi-level Intermediate Representation for Hardware Description Languages
    • LLHD: A Multi-level Intermediate Representation for Hardware Description Languages
    • Moore is a compiler for hardware description languages that outputs llhd assembly
    • MLIR for Hardware Accelerators

• A dependency-free chess engine library built to run anywhere

• crdts: family of thoroughly tested hybrid crdt's

  • Conflict-free replicated data type

• Neovim and Rust

• Is this the right way to read lines from file and split them into words in Rust?

• How to Design For Panic Resilience in Rust

• Rust modules easy explanation

• Rusts Module System Explained

• Rust Design Patterns

• Why I Scatter Use Statements Throughout My Rust

• Alignment of floating point numbers printed in scientific notation

• Fuchsia OS partially written in Rust has shipped

• zig - A general-purpose programming language and toolchain for maintaining robust, optimal, and reusable software

• HVM: a next-gen massively parallel, beta-optimal functional runtime is 50x faster than its predecessors

  • HVM: a next-gen massively parallel, beta-optimal functional runtime is 50x faster than its predecessors
    • High-order Virtual Machine (HVM)

• Deep learning superresolution in pure rust

• Sunrise

  • heliocron
  • Solar Position Algorithm (SPA)
  • sunrise