@rust-lang.org on Bluesky: https://bsky.app/profile/rust-lang.org/post/3lm2r6kfgns2u

Hey folks, I just finished my first blogpost on Pins and subtyping in Rust. I met a number of people who didn't understand these topics, so I decided to compile everything I know in the article.

Here is the link:

https://jujumba.cc/blogposts/your-missed-rust-class/

Would be glad to hear any reviews or error corrections.

Thanks!

It's been a while since my previous post about Algebraeon, a rust-based computational algebra system I have been developing. Since then, I have added faster integer factorization using Lenstras elliptic-curve method and factorization of multi-variable polynomials.

I'm always interested in feedback on the project, especially if you have a pure maths background, have used any computational algebra software, or know of other mathematical rust projects.

Hey r/rust (or other subreddit)!

I wanted to share something I'm really proud of. About 45 days ago, I decided to dive deep into Rust and Leptos to build my first professional web project – a full-stack portfolio site with an admin backend (https://thanon.dev/).

Why Rust/Leptos? I was drawn to Rust's performance, safety guarantees, and the promise of full-stack development with WebAssembly using frameworks like Leptos. It felt like a challenging but rewarding path.

The Project: It's a personal portfolio website designed to showcase projects, skills, etc., but it also includes a secure admin section (built with Leptos server functions) allowing content management directly through the site after logging in.

The Journey: Honestly, it was tough! Getting used to the borrow checker, async Rust, and the reactive concepts in Leptos took serious effort. Managing state, handling server interactions securely, and figuring out deployment were big hurdles. But seeing it all come together, feeling the speed, and knowing the safety net Rust provides has been incredibly rewarding. I learned so much.

Sharing is Caring: I spent a lot of late nights on this, and I wanted to give back to the communities that helped me learn. I've open-sourced the entire project on GitHub:

• Live Demo:https://thanon.dev/
• GitHub Repo:https://github.com/DevsHero/leptos_portfolio_admin

Feel free to check out the code, use it as inspiration, learn from it, or even adapt it for your own portfolio (just update the content!).

Feedback Welcome: As this is my first big Rust project, I'd be grateful for any constructive feedback on the code structure, Rust practices, Leptos usage, or anything else you notice. I'm still learning!

Thanks for checking it out! Excited to continue my journey with Rust.

Hi guys, I just finished my side project - a tool to compare and merge XML semantically. By semantically, it means unorder, i.e it detects the differences in XML tree structure regardless of nodes order.

The project is in early state, looking for usage and feedback, and possible contributions, especially in front-end part since I'm a front-end noobs (it takes me hours to style the damn treeview and it's nowhere near what I desired).

Repo: ndtoan96/xdiffer: XML semantic diff merge tool

First cross compiled app in rust so I wanted to keep the project fairly simple

feel free to roast it, lol

github-link

i wanted to do some project in rust . initially started implementing kilo tutorial in rust later choose to do it the vim way, i wanted to make it safe rust.

i have a question is using Rc<Refcell<>> pointer memory safe way of doing rust? for implementing multiple text buffers i changed the code from Rc<Refcell>> to hash map and a vector storing Hashmap keys.

I am pleased to share that I have just published my first crate. My journey with genetic algorithms started more than a year ago when friend of mine told me about his effort to port his work-in-progress object detection project from C++ to Rust. I joined him in his effort. He was using a genetic algorithm in the app, which piqued my interest. I ended up pulling that part out and starting to build a generic library that would support a whole bunch of genetic algorithms.

The result is genalg. One can compose algorithms with various types of breeding and selection strategies with optional inclusion of various types of local search. Several of each of these are built-in and ready to use, but the trait-based architecture allows to implement custom strategies for specific use cases. There is constraint handling to support combinatorial optimization problems. To optimize for performance, we have options for caching and running some of the processes parallelized.

I'll be happy to receive feedback from seasoned Rustaceans.

Hey Rustaceans,

I have created a video on a programming problem and provided its solution using Rust, please have a look and feel free to givr suggestions ❤️😊🦀 #RustLang

https://youtu.be/qurwRp1VGNI

Hey folks! 👋

I’ve been building this side project called Duva.

One thing I didn’t expect when I started: Rust actually made it easier for me to write a database.

What started as a toy project is now starting to feel like something that could actually go production-grade. No major blockers so far—and honestly, it’s been a lot of fun.

Duva’s using the Actor model under the hood, and right now it supports things like:

• set / get
• Key expiration
• Basic persistence with dumping + WAL (WAL isn’t fully wired up yet)
• Local sharding
• Lock-free architecture
• Gossip-based failure detection
• RAFT-style replicated logs and leader election

What surprised me the most is that, even as someone with zero prior experience in database internals, Rust lets me write and refactor code FEARLESSLY and experiment with things I thought were way out of reach before.

It is still very early days, and there’s tons of room to improve. If you’re into Rust, distributed systems, I’d love your feedback - or even help.

Duva is open source—check it out here( https://github.com/Migorithm/duva ):

And if you like the direction it’s going, a star would mean a lot 💛

Cheers!

I’ve built a crate called overlay-map — it lets you push, pull, and swap values in a two-layered map (foreground + background) without cloning or heap allocations.

Useful for things like speculative updates, non-destructive state changes, or rollback systems.

Includes a standalone Overlay<T> container with a compact, branchless layout and zero-copy transitions.

Source: https://github.com/jameslkingsley/overlay-map

Docs: https://docs.rs/overlay-map

Crate: https://crates.io/crates/overlay-map

This is my first crate — feedback welcome, especially on performance or API design.

fn main() {
    let task1 = async {
        smol::Timer::after(Duration::from_secs(1)).await;
        println!("Task 1");
    };
    let task2 = async {
        smol::Timer::after(Duration::from_micros(700)).await;
        loop {}
        println!("Task 2");
    };

    let ex = smol::Executor::new();

    let t = ex.spawn(task1);
    let j = ex.spawn(task2);

    smol::block_on(async {
        ex.run(t).await;
        ex.run(j).await;
    });
}

If I don't call smol::future::yield_now().await from inside the loop block, I will never see "Task 1" printed to the console. So, the runtime of smol is single-threaded, right?

I've just released structr, a CLI tool that automatically generates typed Rust structs from JSON input. It supports:

• Generating proper Rust types based on JSON data
• Taking multiple JSON samples to create complete schemas
• Handling nested objects and arrays
• Web framework integration (Actix, Axum, Rocket)
• GraphQL support (both async-graphql and juniper)

Installation

bash cargo install structr

Simply pipe in your JSON or point it to a file, and get a ready-to-use struct with proper serialization.

```bash cat data.json | structr --name User

or

structr --input data.json --name User ```

Give it a try and let me know what you think! https://github.com/bahdotsh/structr

https://bsky.app/profile/baileytownsend.dev/post/3llzhgs7ax22m

Dear community,

I just published axum-gate, an (hopefully) easy to use, customizable, role based JWT cookie auth library. It can be used within single nodes as well as distributed systems (eg. with shared secrets). For more information have a look at the example or at docs.rs documentation. I plan to add more backends/storages as time goes on.

Happy to get your feedback and improvement ideas or contributions!

Just published part 3 of my series on building a search engine from scratch in Rust. This time we're diving into making our search engine scalable through sharding and reliable with transactions.

**What's covered:**

- Manifest-based sharding architecture

- Transaction system for safe concurrent operations

- Dynamic shard splitting

- Cross-platform storage abstractions

The article includes detailed explanations, diagrams, and complete code examples. I've focused on making it practical and implementable across different platforms (web, mobile, desktop).

Next up is Part 4 where we'll implement the actual search functionality!

https://youtu.be/g3qd4zpm1LA

They include a part „Why not Rust?“ at 27:17

Description: Jane Street is a trading firm that uses a variety of high-performance systems built in OCaml to provide liquidity to financial markets worldwide. Over the last couple of years, we have started developing major extensions to OCaml’s type system, with the primary goal of making OCaml a better language for writing high-performance systems. In this talk, we will attempt to provide a developer's-eye view of these changes. We’ll cover two major directions of innovation: first, the addition of modal types to OCaml, which opens up a variety of ambitious features, like memory-safe stack-allocation; type-level tracking of effects, and data-race freedom guarantees for multicore code. The second is the addition of a kind system to OCaml, which provides more control over the representation of memory, in particular allowing for structured data to be represented in a cache-and-prefetch-friendly tabular form. Together, these features pull together some of the most important features for writing high performance code in Rust, while maintaining the relative simplicity of programming in OCaml. In all of this, we will focus less on the type theory, and more on how these features are surfaced to users, the practical problems that they help us solve, and the place in the design space of programming languages that this leaves us in.

TLDR: according to you, what is a more flexible, extensible and easy to use alternative to diesel-rs and why ? I have been working on a project from the past year that uses an SQLite database with diesel, it's has been good so far. But from past few months, I have been growing to dislike diesel, it's amazing and all but I feel that alot of my application has to be designed in a way that fits diesel for some reason. I have to keep the database file at a certain location, I have to keep models at a certain location, and it is just suffocating for some reason. All I have ever used is diesel and don't even know what to choose as replacement. If I choose to switch, depending upon what I switch to, I estimate it to take almost 4 hours which is not alot but still it's a considerable amount of time.

If you can please suggest some alternatives that don't feel suffocating like this and offer me to be a little more flexible, it would be amazing.

Any help is appreciated!

I really like the color theme used in the Rust documentation, does anyone know of an editor theme that uses the same color scheme?

It is just for hobby, of course, and it is just at the beginning. But i plan to make it a real language that people can use. It is just at the beginning, so if you're interested contributing is well accepted. It is written in Rust to be as safe as possible.

https://github.com/gianndev/mussel

You can also just try it and tell me what do you think. Even just a star on github means a lot for me. Thanks.