Due to a misbehaving crawler taking down docs.rs three times, we now added rate limiting.
This shouldn't impact any normal user, we're happy to talk if this affects you.
Officially we follow the crates.io data policy, so crawlers should be limited to 1 request per second. Until now we didn't validate / limit that and relied on the sanity of the crawlers.
Uploaded a little Rust app called "Doxa" used for OSINT discovery and pivot. It kinda works, more to come.
I quite like "#[deny[clippy::unwrap_used)]", outside test code, but it does require me to break my habit of just letting code panic on unexpected conditions, instead of noticing them and returning an error.
The #Rust crate `csv` has a very clever design.
It parses CSV one byte at a time using a state machine. It has only a few states, none of which have any associated data, so it uses its configuration (delimiter character, quote character, etc) to populate a big table of what to do in every possible combination of state and input byte.
In theory, that is very fast.
I wonder…would it be faster still, if the state machine was generated at compile time by a proc macro?
In today’s #rust adventure, I successfully sideloaded a #python subprocess!
In today’s #python adventure, I successfully sideloaded a #javascript subprocess!
Apparently I’m at the stage of my career where I shove languages into other languages (I swear I have a good reason in both instances!)
I think I found something weird & scary with `#[target_feature]`. Is this expected?
This feels like it should *at minimum* trigger a lint. How am I supposed to know whether trait impls added extra safety preconditions — especially when using `dyn/impl Trait` and/or an unsealed trait?
![pub trait Example {
unsafe fn demo(&self) {}
}
pub struct S;
impl Example for S {
// This isn't applied to the trait's fn!
#[target_feature(enable = "avx2,aes")]
unsafe fn demo(&self) {}
}
pub fn accept_dyn(value: &dyn Example) {
// SAFETY: umm ???
// Who knows what #[target_feature]
// attributes the trait impl has imposed?!
unsafe { value.demo() }
}](https://media.hachyderm.io/media_attachments/files/114/277/042/404/600/437/original/031396318ac475b3.png "pub trait Example {
unsafe fn demo(&self) {}
}
pub struct S;
impl Example for S {
// This isn't applied to the trait's fn!
#[target_feature(enable = \"avx2,aes\")]
unsafe fn demo(&self) {}
}
pub fn accept_dyn(value: &dyn Example) {
// SAFETY: umm ???
// Who knows what #[target_feature]
// attributes the trait impl has imposed?!
unsafe { value.demo() }
}")
i'm more of a turbofish guy myself though
Nice new milestone for #embedded #Rust development: defmt 1.0 has been released. The crate enables logging for microcontrollers without text or number formatting on the device – instead, the device sends numbers of interned strings to the host, which composes log messages.
1.0 is not only a stable release, but also enables logging #CBOR data into diagnostic notation on the host.
Deadlock-free Mutexes and Directed Acyclic Graphs (2022) https://lobste.rs/s/9p2yca #rust
https://bertptrs.nl/2022/06/23/deadlock-free-mutexes-and-directed-acyclic-graphs.html
![one_char_diff(String1, String2) :-
atom_chars(String1, Chars1),
atom_chars(String2, Chars2),
dist(Chars1, Chars2, 0, N),
N = 1.
dist([], [], C, R) :- C = R.
dist([H1|T1], [H2|T2], Count, R) :-
(H1 \= H2 -> NewCount is Count + 1 ; NewCount is Count),
dist(T1, T2, NewCount, R).
construct_path([H|T], End, _, Path) :-
H = End,
reverse([H|T], Path).
construct_path([H|T], End, G, Path) :-
member((H, Next), G),
\+ member(Next, T),
construct_path([Next, H|T], End, G, Path).
cmp_length(A, B) :-
length(A, La),
length(B, Lb),
La =< Lb.
find_word_ladder(Start, End, Dictionary, Result) :-
findall((Word1, Word2),
(member(Word1, Dictionary), member(Word2, Dictionary), one_char_diff(Word1, Word2)),
G),
findall(Path, construct_path([Start], End, G, Path), Paths),
min_member(cmp_length, Result, Paths).](https://files.mastodon.social/media_attachments/files/114/275/910/992/824/365/original/686d944c7bd9745d.png "one_char_diff(String1, String2) :-
atom_chars(String1, Chars1),
atom_chars(String2, Chars2),
dist(Chars1, Chars2, 0, N),
N = 1.
dist([], [], C, R) :- C = R.
dist([H1|T1], [H2|T2], Count, R) :-
(H1 \= H2 -> NewCount is Count + 1 ; NewCount is Count),
dist(T1, T2, NewCount, R).
construct_path([H|T], End, _, Path) :-
H = End,
reverse([H|T], Path).
construct_path([H|T], End, G, Path) :-
member((H, Next), G),
\+ member(Next, T),
construct_path([Next, H|T], End, G, Path).
cmp_length(A, B) :-
length(A, La),
length(B, Lb),
La =< Lb.
find_word_ladder(Start, End, Dictionary, Result) :-
findall((Word1, Word2),
(member(Word1, Dictionary), member(Word2, Dictionary), one_char_diff(Word1, Word2)),
G),
findall(Path, construct_path([Start], End, G, Path), Paths),
min_member(cmp_length, Result, Paths).")
![fn dist(a: &str, b: &str) -> u32 {
a.chars().zip(b.chars()).fold(0, |d, (a, b)| d+(a!=b) as u32)
}
fn find_word_ladder(start: String, end: String, dictionary: Vec<String>) -> Option<Vec<String>> {
let mut g: Vec<(&str,&str)> = vec![];
for i in 0..dictionary.len() {
for j in (i+1)..dictionary.len() {
if dist(&dictionary[i], &dictionary[j]) == 1 {
g.push((&dictionary[i], &dictionary[j]));
}
}
}
let mut paths: Vec<Vec<&str>> = vec![vec![&start]];
let mut results: Vec<Vec<&str>> = vec![];
while paths.len() > 0 {
let p = paths.pop().unwrap();
let t = p.last().unwrap();
for (x,y) in g.iter() {
if x == t {
let mut pc = p.clone();
pc.push(y);
paths.push(pc);
}
}
if t == &end {
results.push(p);
}
}
results.into_iter().max_by(|a,b| a.len().cmp(&b.len()))
.map(|v| v.into_iter().map(|s| s.to_owned()).collect())
}](https://files.mastodon.social/media_attachments/files/114/275/910/994/785/416/original/17b89dd86b78c96b.png "fn dist(a: &str, b: &str) -> u32 {
a.chars().zip(b.chars()).fold(0, |d, (a, b)| d+(a!=b) as u32)
}
fn find_word_ladder(start: String, end: String, dictionary: Vec<String>) -> Option<Vec<String>> {
let mut g: Vec<(&str,&str)> = vec![];
for i in 0..dictionary.len() {
for j in (i+1)..dictionary.len() {
if dist(&dictionary[i], &dictionary[j]) == 1 {
g.push((&dictionary[i], &dictionary[j]));
}
}
}
let mut paths: Vec<Vec<&str>> = vec![vec![&start]];
let mut results: Vec<Vec<&str>> = vec![];
while paths.len() > 0 {
let p = paths.pop().unwrap();
let t = p.last().unwrap();
for (x,y) in g.iter() {
if x == t {
let mut pc = p.clone();
pc.push(y);
paths.push(pc);
}
}
if t == &end {
results.push(p);
}
}
results.into_iter().max_by(|a,b| a.len().cmp(&b.len()))
.map(|v| v.into_iter().map(|s| s.to_owned()).collect())
}")
Trying to decompile a rust binary... anyone got a useful program? Not ghidra, binary.ninja...
regname: Mass renamer TUI written in Rust https://lobste.rs/s/zxpqz0 #show #rust
https://github.com/linkdd/regname
#Rust
1.86.0 released by @rust - New features: trait upcasting, HashMaps and slices indexing multiple elements mutably, safe functions marked with #[target_feature], debug assertions that pointers are non-null when required for soundness, make missing_abi lint warn by default, etc. https://blog.rust-lang.org/2025/04/03/Rust-1.86.0.html #RustLang #OpenSource #cybersecurity #software #engineering #tech
![article overview screenshot - follow link for full text
Rust Blog
Announcing Rust 1.86.0
Apr. 3, 2025 · The Rust Release Team
The Rust team is happy to announce a new version of Rust, 1.86.0. Rust is a programming language empowering everyone to build reliable and efficient software.
What's in 1.86.0 stable
Trait upcasting
This release includes a long awaited feature — the ability to upcast trait objects. If a trait has a supertrait you can coerce a reference to said trait object to a reference to a trait object of the supertrait:
trait Trait: Supertrait {}
trait Supertrait {}
fn upcast(x: &dyn Trait) -> &dyn Supertrait {
x
}
The same would work with any other kind of (smart-)pointer, like Arc<dyn Trait> -> Arc<dyn Supertrait> or *const dyn Trait -> *const dyn Supertrait.
[...]](https://files.pnw.zone/media_attachments/files/114/275/448/354/378/910/original/699999ff4b9d9bd3.png "article overview screenshot - follow link for full text
Rust Blog
Announcing Rust 1.86.0
Apr. 3, 2025 · The Rust Release Team
The Rust team is happy to announce a new version of Rust, 1.86.0. Rust is a programming language empowering everyone to build reliable and efficient software.
What's in 1.86.0 stable
Trait upcasting
This release includes a long awaited feature — the ability to upcast trait objects. If a trait has a supertrait you can coerce a reference to said trait object to a reference to a trait object of the supertrait:
trait Trait: Supertrait {}
trait Supertrait {}
fn upcast(x: &dyn Trait) -> &dyn Supertrait {
x
}
The same would work with any other kind of (smart-)pointer, like Arc<dyn Trait> -> Arc<dyn Supertrait> or *const dyn Trait -> *const dyn Supertrait.
[...]")
Show HN: Zxc – Rust TLS proxy with tmux and Vim as UI, BurpSuite alternative
Link: https://github.com/hail-hydrant/zxc
Discussion: https://news.ycombinator.com/item?id=43568771
I'm using Rust's Macroquad crate to make a small game, and so far it is exactly the right level of abstraction for this project.
(Bevy is great, but its more than what I need for this project)/
I especially like that because it isn't opinionated, it gives me the chance to build my own game loop and ECS so I better understand how more sophisticated game engines (like bevy) work.
I'm really looking forward to deploying this to WASM and trying out mobile support.
Looks like a cool job: https://typst.app/jobs/ @faassen aren't you looking for an interesting #Rust challenge? Don't know whether they can pay you, but it sounds like fun.
Rust 1.86 is out now, bringing trait upcasting support, safer mutable indexing for slices and maps, and stable target feature support for safe functions.
https://linuxiac.com/rust-1-86-introduces-major-language-features/
