We finally run the libcore tests with rustc_codegen_gcc in the CI of the Rust repo, which should help us a lot with the future syncs. We also finally merged a few more GCC patches, so the gap with upstream is slowly decreasing.

I'm kinda still shopping around for a good graphical filemanager. This is of course still very raw, but the tagging system might actually take care of the bookmark aspect, which is very important to me.

Hocusfocus is a tool I made to track how long you spend on certain tasks (Working, Studying, Wasting time).

It was initially written in Swift, but was rewritten in Go a while ago. Now, I’ve rewritten it in Rust.

geteilt von: https://programming.dev/post/52041408

Have you ever thought about sharing data across language boundaries without serialization? This blog post highlights the challenges behind this endeavor and how they can be overcome.

Note: I'm not the original author of the blog post, but since the author does not have a programming.dev account, I post it on his behalf.

Who Runs Your Rust Future? Hands-On Intro to Async Rust

I wrote a hands-on intro to async Rust where you build a future and the runner that drives it. It assumes you've written async/await in JS and know Rust basics (structs, enums, closures). No prior async Rust needed.

What the first chapter covers:

• Who actually runs your async code in Rust
• What calling an async function actually does, compared to a JS Promise
• What 'running' a future actually means, step by step
• The waker: how a future says when it's worth polling again, so you can sleep instead of spinning the CPU
• Building a Oneshot channel by hand
• Writing block_on, a runner that drives a future to completion

Everything is built from std only, no dependencies. Also, this chapter is a part of a bigger series that goes deep into async Rust.

Crossposted from https://lemmy.ml/post/48563577

Initial release of FLI - really tiny and fast (like a 🪰) directory listing tool.

Initial Why: need some easy readable ls like tool for rpi to use via ssh.

Current Why: check if with Rust one can build core utils like tools faster and smaller.

• Size:

18K - RPI ZERO W

51KB - Mac

• Default mode streams readdir() => stdout with zero heap allocation.

• Nice readabilty thx to (📄 and 🗂️) instead of text coloring

• Written in no_std #rust + libc.

https:// github.com/tracyspacy/fli

Is there any guide, tutorial or other resource that helps in making a REPL-based DSL using rust

Bevy Game Engine Explained Visually

A visual tour of how Bevy helps you compose complex, emergent games from small independent systems and a data-driven architecture.

Tutorial Link

Chapter 7 - Let There Be Enemies

Continuing my Bevy + Rust tutorial series. Learn to build intelligent enemies that hunt and attack the player using A* pathfinding and AI behavior systems.

By the end of this chapter, you'll learn:

• Implement A* pathfinding for enemies to navigate around obstacles
• Reuse player systems for enemies (movement, animation, combat)
• Build AI behaviors