I’ve been building distributed compute/database infrastructure in Rust and realized there doesn’t seem to be a clean standalone Timestamp Oracle (TSO) library in the ecosystem (or at least, not a solid one to my knowledge).

So I built one: https://github.com/prisma-risk/tsoracle

The initial use case was OpenRaft-based systems where multiple nodes need:

• globally ordered timestamps
• snapshot isolation / MVCC-style semantics
• deterministic event ordering
• monotonic IDs
• causality/version tracking

One thing I specifically wanted was a pluggable consensus layer, so I added an OpenRaft cluster example here: https://github.com/prisma-risk/tsoracle/tree/main/examples/openraft-cluster

The basic idea:

• OpenRaft elects a leader
• leader allocates timestamp batches
• timestamps remain strictly monotonic
• persistence guarantees survive failover/restart
• clients fetch timestamps over gRPC

Example use cases: MVCC storage engines, distributed schedulers, event sourcing, CDC pipelines, globally ordered audit logs,...

Welcoming any feedback and contributions 😄

I've been working with Rust for couple years now and really love how clean the abstraction layers are compared to other languages I use

The thing that got me thinking about this - every language has those moments where you dig deeper and suddenly realize "oh wait, this thing I thought worked one way actually works completely different under the hood"

Like in Python when you discover that `len()` isn't just a regular method call but uses magic methods because of all the mutability stuff happening behind scenes. Or how C lets you do weird things like `5[array]` instead of `array[5]` because it's all just pointer arithmetic anyway

Rust seems really good at keeping these implementation details hidden from daily programming, but I'm curious what kinds of things are happening under surface that most people never run into

What are some examples where Rust's abstractions start showing their seams if you look close enough? The kind of stuff that works fine 99% of time but then you hit some edge case and suddenly need to understand what's really going on

Greetings,

I started programming pretty intensively about a year and a half ago. I come mostly from data analysis, so I naturally started with Python / SQL. Which has been great for the first self-built stuff I pushed to production. Users loved what I built, I was enjoying my new full time programming job, etc. (Note that i don't have any CS degree, i'm not gifted, i'm mostly very dedicated / hardworking.)

Then I started to meet "Python inherent problems" in terms of:

• Space and time complexity
• Really too many lib dependencies
• Too much "magic" or "abstraction"

When I talk about abstraction, I mean deeply nested OOP hierarchies where every method call goes through 5 layers of indirection you can't easily trace. I don't mind explicit contracts (I actually love strong typing and schemas), what I dislike is implicit magic: dependency injection containers, hidden decorators, frameworks where you have to "just know" how things wire together. I prefer sequential, traceable code: data pipelines where you can follow the flow from top to bottom. I don't mind complex steps as long as what they do is written in the code.

I never wrote a single line of Rust, but I think I'm starting to understand its philosophy by using Polars (sweet lord I love pl.LazyFrame).

I don't mind complexity, I'd just like to spend time learning something that I'd still be using in the long run. Instead of learning abstract stuff built in a library or a framework that I'll be using in one or two projects and then just forget.

I don't have any "Rust" friends, most of my contacts in programming come from Java / PHP Symfony.

On paper, Rust sounds like a very promising language to learn and master that combines with my natural need of understanding what's under the hood. But maybe i'm writing fantasy in my own mind, so i'd love to know if you understand my needs and if Rust could help me 😄

Thanks

I'm starting to learn rust, and I plan to develop a small project as I'm learning, but I'm undecided about which one to do. I already have a list of projects I want to develop in different programming languages, so I want to know what kind of projects rust is better for. If anyone wants to show me a project they've made that could be an example, it would be pretty nice.

I have already learned C/C++ if that helps tou give me better recommendations

Disclaimer: This is not a where to learn / find learning material post, but rather a question on practicality of using Rust.

I was hoping to hear opinions/anecdotes on your current experience in using Rust in practice.

Context:

I am a Typescript developer who runs and manages a web-dev/web-design agency, have some free-time during the weekends + evenings and wanted to pick up a new programming language (I dove deep for years into TS/JS and ignored everything else).

At first, I've looked at Ruby.

It's pretty close to home (we use AdonisJS) and Rails has proven itself over the years.

However, Loco and Tokio seemed even more interesting, but the counter-point to that - is that the practicality of eventually integrating it in a web-dev shop is a big question mark.

These are the main reasons that I've had in mind for learning Rust:

1. To build side-projects / hobby-projects / and (if feasible) even internal tooling / plugins for node.
2. Spread out from Typescript and Node to try something new, broaden my horizons, and sharpen my skills.
3. We usually work with low-resource servers and rather optimize around the hardware limitations. I've seen people saying on Reddit that Loco and Rust backends are so low on resource use, that it naturally sparked my interest.
4. Because at times, there are projects where I have to overlook a team - we always NEED a conventions over configurations frameworks (AdonisJS, Rails, Laravel). Loco seems to hit the spot.

Obviously, this is with a very generous timeline in mind and is thinking almost a year in advance. However, there are considerations that I am unable to find a concrete answer on:

1. Long term maintainability and stability is a big concern. How likely is it for current libraries/frameworks to be abandoned? Chances of major vulnerabilities popping-up (i.e: NextJS every once in a while is too much).
2. Practicality: Does it make sense to learn Rust to build internal tooling and plugins, when NodeJS itself would suffice?
3. (Expanding on 2): Would learning Rust improve my current knowledge and capabilities enough to warrant, say, the worst case scenario of never having to use Tokio or Loco or WASM?
4. Scaling: Not infrastructure or code-wise, rather, finding the relevant talent in GCC, with sufficient capabilities, at a reasonable price?

Apologies for the weird title, I stared at it for around 5 minutes and couldn't come up with a better one.

And thank you in advance, any answer is greatly appreciated.

Appreciate the feedback on my last post about whether I should rewrite the web crawler layer of my local RAG system from Go to Rust. Someone rightfully called me out for not explicitly defining my project goals and looking for a "how" in search of a "why."

To clear up the confusion: this isn't just a textbook learning project for fun (Goal A), nor is it an enterprise application with thousands of active users that I'm terrified of breaking (Goal B).

This is a self-hosted, personal production stack designed to ingest thousands of dynamic, JS-heavy data sources. My operational goals are system reliability, predictable long-term maintenance, and memory efficiency under heavy parallel loads.

Right now, the architecture is split:

Ingestion Layer: Built on Lyzr-Crawl (github.com/LyzrCore/lyzr-crawl). It’s a dedicated open-source Go engine that handles the heavy lifting—headless JS rendering, parallel URL discovery, and clean Markdown extraction so my LLM context windows don't get flooded with raw HTML/CSS bloat.

Core Pipeline Layer: A custom Rust stack utilizing tokio for heavy async coordination, text splitting, chunk embeddings, and streaming updates to a local vector store.

The Go binary is incredibly fast out of the box due to native goroutines, and it successfully saves me from paying insane per-page SaaS scraping API fees. But running a split-language stack introduces a lot of micro-frustrations that are pushing me toward a full Rust unification:

The Maintenance "Why": Debugging across a language boundary sucks. Passing structured data from Go's runtime over IPC/gRPC into Rust's async environment introduces extra serialization overhead and means I'm maintaining two completely different error_handling mental models. If a network timeout or headless crash occurs inside the crawler, bubbling that up deterministically to my Rust logic is clunky.embedding models.

The Resource "Why": Since I run this pipeline locally on a single machine alongside the LLM/Vector store, every megabyte counts. Go’s garbage collector is aggressive under high concurrent I/O, causing random memory spikes. I want Rust's zero-cost abstractions and strict memory predictability so the ingestion layer doesn't choke out the resources needed for local embedding models.

So my specific technical question for the sub remains:

If my goal is long-term stability and rock-solid error handling across the entire pipeline, is it worth writing a custom, production-grade equivalent to Lyzr-Crawl using reqwest + headless_chrome in Rust? Or will the sheer development overhead of rebuilding highly optimized, multi-threaded Go crawling primitives from scratch outweigh any performance and architectural synchronization gains I get from a single-language stack?

Also likes being efficient is good overall

Like I need a good mixture of efficiency and reliability

English isn't my first language as u can tell from my previous post where I messed up some verbs so I first wrote my post in a notepad and then ran it through grammarly this time around

Oh also what would happen if I switch over to watercrawl from lyzrcrawl?

Hello, I've been learning PyO3 to rewrite some python functions in Rust.

I have one project intensive in regex parsing, and I thought that switching to Rust could bring improvements.

Yet, I haven't been able to beat Python's RE (yes, I know it's written in C). Parsing 1 single line, RE(2 microseconds), PyO3+Rust's regex (3 microseconds).

What I have tried:

* Using OnceLock to emulate Python's re.compile. (As expected this was important)
* Return a tuple instead of a struct. (The same)
* Try adding Rayon and testing in batch. (No luck)

If you had any idea it would be appreciated.

Below is my rust code, the python's side it's just a pytest source file that imports the rust library. I use pytest-benchmark for the benchmarking:

use pyo3::prelude::*;

/// A Python module implemented in Rust.

#[pymodule]

mod sysadmindb_rs {

use pyo3::exceptions::PyValueError;

use pyo3::prelude::*;

use rayon::prelude::*;

use regex::Regex;

use std::sync::OnceLock;

fn log_pattern() -> &'static Regex {

static RE: OnceLock<Regex> = OnceLock::new();

RE.get_or_init(|| Regex::new(r"<(?<prival>[0-9]+)>(?<version>[0-9])?\s?(?<date>([0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]+(Z|[+-][0-9]{2}:[0-9]{2})|\w{3}\s[0-9]{2}\s[0-9]{2}:[0-9]{2}:[0-9]{2}))\s(?<hostname>[\w.]+)\s(?<appname>[\w.]+)\s?\[?(?<procid>[0-9-]+)?\]?\:?\s?(?<msgid>(-|\w{2}[0-9]{2}))?\s?(?<structureddata>(\[.+\]|-))?\s?(BOM)?(?<msg>.+)?").unwrap())

}

#[pyclass]

struct Log {

#[pyo3(get)]

version: Option<u32>,

#[pyo3(get)]

prival: u32,

#[pyo3(get)]

date: String,

#[pyo3(get)]

hostname: String,

#[pyo3(get)]

appname: String,

#[pyo3(get)]

procid: String,

#[pyo3(get)]

msgid: String,

#[pyo3(get)]

structureddata: String,

#[pyo3(get)]

msg: String,

}

#[pymethods]

impl Log {

#[new]

fn new(line: &str) -> PyResult<Self> {

match parse_log(line) {

Ok(log) => Ok(log),

Err(_) => Err(PyValueError::new_err("Cannot parse")),

}

}

}

fn parse_log(line: &str) -> Result<Log, String> {

let Some(caps) = log_pattern().captures(&line) else {

return Err("sorry".to_string());

};

Ok(Log {

prival: caps["prival"].parse().unwrap(),

version: caps.name("version").map(|m| m.as_str().parse().unwrap()),

date: caps["date"].to_owned(),

hostname: caps["hostname"].to_owned(),

appname: caps["appname"].to_owned(),

procid: caps["procid"].to_owned(),

msgid: caps["msgid"].to_owned(),

structureddata: caps["structureddata"].to_owned(),

msg: caps

.name("msg")

.map(|m| m.as_str().to_owned())

.unwrap_or_default(),

})

}

I selected several Rust decimal crates, discussed and compared their features, and conducted extensive benchmarking on them.

If you think there are other better decimal crates, feel free to suggest them. We can discuss them or add them to this benchmark comparison.

Change Risk Anti-Patterns (CRAP) metric for Rust projects.

This is the link to the main track. For the other two tracks, see https://rustweek.org/live