Technical Articles
2025-01-20

Running Rust Programs on Arduino Uno: A Comprehensive Guide

Running Rust Programs on Arduino Uno

A long time ago, to run Rust on Arduino, you had to install a specially modified Rust compiler that supports AVR: rust-avr. A month ago, rust-avr has been merged into the Rust master branch, which means you can play with Arduino under Nightly now.
It also includes a new book, The AVR-Rust Guidebook: https://book.avr-rust.com/
The official website of the rust-avr project: https://www.avr-rust.com/
This article is a tutorial.
https://dev.to/creativcoder/how-to-run-rust-on-arduino-uno-40c0
via https://t.me/rust_daily_news/4495

Discussion on Rust for Deep Learning

The discussion is quite heated, so I added it here.
Address: https://www.reddit.com/r/rust/comments/igz8iv/deep_learning_in_rust/
Rust Machine Learning Working Group: https://github.com/rust-ml
Like other working groups, there is a summary site: https://www.arewelearningyet.com/
Possible libraries: ① https://github.com/raskr/rust-autograd ② https://github.com/spearow/juice

Performance Testing of the Rapier Physics Engine

Rapier announced its source code a couple of days ago along with this blog.
Address: https://www.dimforge.com/blog/2020/08/25/announcing-the-rapier-physics-engine/
Not only does it have performance comparison tests with box2d and physx, but this blog also compares the current features with its predecessor nphyscis and states that missing features will be improved in the coming months. It also provides the official Bevy plugin: https://github.com/dimforge/bevy_rapier
The paper mentions that there was also a plugin specifically for the Amethyst engine, but Amethyst is currently migrating their ECS backend. Official maintenance of the physics engine plugin for Amethyst will only be provided after this part of the work is completed.

A Small Demonstration of Visual Programming in Rust

They are about to release a book on visual low-level programming, so they released this small demo.
Address (requires VPN): https://www.youtube.com/watch?v=zTpzyYtE5oY

A Summary of Rustconf 2020 by Tikv Official Website

Read More: https://tikv.org/blog/rustconf-20/

A New SQL Database: GlueSQL

It is still in a very early stage, but basic SQL queries are already supported.
Address: https://github.com/gluesql/gluesql

Fixing the include_bytes! Macro

include_bytes! macro should be familiar to everyone. The author found it not so easy to use during the process, and there were places where it did not meet the author’s expectations. This blog introduces some of the problems the author encountered and how they were fixed.
Read More: https://jack.wrenn.fyi/blog/include-transmute/

Thread Pools in Rust

The author wrote a tutorial on thread pools in Rust using the Rayon library.
Read More: https://pkolaczk.github.io/multiple-threadpools-rust/

Constany: A crate that converts any Rust function to a const function

The library’s documentation mentions some principles behind this library.
Address: https://github.com/moelife-coder/constany

Bevy Source Code Learning Notes – 001

Recently, I have been looking at Bevy’s source code and sharing some interesting parts with everyone.
I have seen relatively little, so I only found some brief parts.
Since I am not too familiar with Bevy’s asset handling, I prioritized looking at this part of the source code.
// I didn't look at the Properties macro part, but when I saw the introduction of Bevy engine at that time, it was said that this was specially designed to achieve functionality similar to reflection in other languages in Rust. #[derive(Properties)] pub struct Handle where T: 'static, { // pub struct HandleId(pub Uuid); pub id: HandleId, #[property(ignore)] marker: PhantomData, }
I find this part of the source code quite interesting because in addition to the Handle structure, another structure is implemented in this part of the source code:
#[derive(Hash, Copy, Clone, Eq, PartialEq, Debug)] pub struct HandleUntyped { pub id: HandleId, pub type_id: TypeId, }
Most of the operation methods on Handle are implemented in Handle, so what is the significance of implementing HandleUntyped? The comments in the source code explain this very well: This allows handles to be mingled in a cross-asset context. For example, storing Handle<A> and Handle<B> in the same HashSet<HandleUntyped>.
Currently, I have only looked at the asset part, the more complex processing should be in the AssetServer part, but basically all are normal codes, with no clever tricks like the above.

Recommendation for a Bilibili User

A few days ago, I stumbled upon a Bilibili user who solves LeetCode problems using Rust, and the video quality is excellent.
However, the view count of one video is pitifully low. Interested viewers can give it a follow.
Address: https://space.bilibili.com/202107274/
It’s recommended to watch the part where he solves LeetCode problems, I personally think this is the best he has done in the series.

This Week in Rust

The beloved issue number 353.
Read More: https://this-week-in-rust.org/blog/2020/08/26/this-week-in-rust-353/
From the Daily Report Team Downtime Jancd

Related posts

Leave a Comment

Your email address will not be published. Required fields are marked *