What's everyone working on this week (45/2026)?

New week, new Rust! What are you folks up to?

Some fixes for uutils awk, uutils coreutils. Got CI fixed in awk and the test-patching env set up, so doing further fixes should much easier now.

In the last 2 weeks I have updated an event-parsing streaming JSON library, yajlish, that I made in about 2020. I have switched out the lexer to be written using logos.

This week I am going to write a blog post about the formal verification with kani and fuzzing with bolero that I did on the library.

Learning how to make a parser for a custom single-purpose scripting language, more specifically figuring out how to reliably parse chained and grouped conditionals like "(A and B) or (C and D)" into a serializable evaluation tree structure. Also learning that making the intended case work is much easier than figuring out how to handle all the ways a user might get the syntax wrong.

You might like something like chumsky or nom, or just logos (which the other post mentioned) with a manual Pratt parser. Personally I've been using logos since 2021 and couldn't be happier, tho chumsky is easily the easiest pick since it's got lexing, parser recoverability + nice error messages, and Pratt parsing built-in.

Edit: your description sounds awfully similar to SAT and is intriguing me.

I am working on polishing my small ui framework. now it able to run on more platform.


Excited to have anyone interest with it: https://github.com/aimer-rs/aimer

Tiny client library for NetBSD's blocklistd (with ambitions of growing into an independent implementation of the daemon side, because I have Ideas about that)

This week, I’ve been tweaking the font rendering, and added support for color emojis. This was implemented by switching between R8Unorm and Rgba8UnormSrgb texture atlases. I also spent some time cleaning up the renderer, as it was starting to get bloated.

Alongside wgpu, michiu leverages DirectComposition. This unlocks a lot of interesting possibilities, though it can be quite tricky to tame.

Feel free to check it out! Any feedback or thoughts are more than welcome:

Not much Rust activity on my side this week. I made a small fix for source-mesh: added test coverage calculation (for now it's just a number, without enforcing a hard threshold in CI), optimized dependency graph construction, and reduced the number of allocations.

I also tried using Stringlet in both source-mesh and another private project. However, based on the benchmarks, I didn't see any real benefit. That probably has more to do with the way strings are used in those projects than with Stringlet itself.

If you don't want to use a parser generator, you'll likely end up making a recursive descent parser, so a top-down parser. For expressions in general, I suggest looking up precedence climbing or Pratt parsing (same concept, the latter being a generalization). It's the most efficient method, and it's easier to adjust the priority / associativity of the operators.

Sandler's Writing a C Compiler is a great hands-on book on the topic. The author implemented the compiler in OCaml, but it's possible to find an online Rust version, as support (in the book, she uses pseudo-code).

If you're just interested in the result, though, just use a generator. It'll be much easier if you need to change the grammar later.

Production-grade implementations of major programming languages almost always use hand-coded recursive descent parsers and this is why. It's much easier to control error recovery behavior and fine-tune diagnostics when you have total manual control over, er, control flow.

Theoretically, PEG parser generators can give you the best of both worlds, and CPython has been experimenting with that in the last few releases, but they can have nasty resource consumption problems.

Resynchronising a bottom-up parser isn't too difficult, and it's possible to let the user insert fake values of their choosing for the symbols that must be created (or notify which ones are removed). Creating good error messages is definitely tedious, but I think it's the case for any type of parser.

The whole error reporting and recovery is probably more intuitive in recursive descent parsers, though. On the other hand, top-down parsers, even with a variable number of lookahead tokens, suffer from annoying limitations for programming languages, and a recursive implementation comes with its own share of problems.

So I'm wondering if the choice of such parsers for some of the programming languages isn't more driven simply by the unavailability of parser generators for new languages and the relative easiness to bootstrap the process by controlling which part of the languages is used initially.

Perhaps it's easier and more natural for people aren't too familiar with bottom-up parsers, too. When I first used Yacc and was presented with a shift/reduce conflict, I didn't know yet how those parsers worked, and it was rather intimidating. :sweat_smile:

I continue working on historia - event-driven rust framework. I'm working on sagas at the separate branch. At this moment I finished basic but fully working coordinated sagas. It already supports compensations and most of boilerplate code can be implemented using simple macros. Here's some basic example of defining saga using the framework:

use serde::{Serialize, Deserialize};
use historia::{Saga, SagaEvent};

#[derive(Serialize, Deserialize)]
struct Order {
    id: String,
}

// It's possible to use any enum variant names or any data inside there.
// At this example the same data used for all variants for simplicity.
#[derive(Serialize, Deserialize, SagaEvent)]
#[serde(untagged)]
pub enum FirstSagaStep {
    #[saga_event(request)]
    Request(Order),
    #[saga_event(ok_response)]
    OkResponse(Order),
    #[saga_event(err_response)]
    ErrResponse(Order),
    #[saga_event(compensate_request)]
    CompensationReq(Order),
    #[saga_event(compensate_response)]
    CompensationResponse(Order),
}

#[derive(Serialize, Deserialize, SagaEvent)]
#[serde(untagged)]
pub enum SecondSagaStep {
    #[saga_event(request)]
    Request(Order),
    #[saga_event(ok_response)]
    OkResponse(Order),
    // We can skip err_response if the step is unfallible
    #[saga_event(compensate_request)]
    CompensationReq(Order),
    #[saga_event(compensate_response)]
    CompensationResponse(Order),
}

#[derive(Serialize, Deserialize, SagaEvent)]
#[serde(untagged)]
pub enum ThirdSagaStep {
    #[saga_event(request)]
    Request(Order),
    #[saga_event(ok_response)]
    OkResponse(Order),
    // We can also skip compensation events if they're not necessary
}

#[derive(Saga)]
pub enum ExampleSaga {
    First(FirstSagaStep),
    Second(SecondSagaStep),
    Third(ThirdSagaStep),
}

This small definition (though it might be customized) will generate all required implementations of the saga-related traits and generate a few new for each step - coordinator handlers and processor handlers - which can be implemented in the user's services in order to handle those events.

I'm going to keep work on the sagas implementation. The most important thing which is also main release blocker is timeouts handling - that's what I'm plan to focus this week and probably the next one alongside with polishing and documenting how it works and how it can be used. Anyway, working example can already be found in the repo, here (example is a bit messy atm, I'll work on it a bit later too).

I think it's actually more about which parser algorithms have readily available parser generators, and the ergonomics of those parser generators. Yacc was impressive in 1980, starting to show its rough edges in 1990, and strictly for prototypes and miniature tasks in 2000 ... but nothing has really emerged as a replacement, and furthermore, the limitations of LALR(1) have, I think, put a lot of people off the whole idea.

The ergonomics of inserting code in the grammar itself were pretty bad, but they have improved. One of the best examples I've seen is the interface model used in ANTLR.

LALR causes some problems with its inadequacies, but IELR was added in Bison to remedy that, and later Hocc has invented the quasi-dual APLR (there were other attempts before that). Most people are unaware of those problems anyway, or they see LALR as a good compromise.

A web inventory app with very limited scope (for now).

Currently using Rocket for the web framework - Sqlite as the db - Diesel for the db interaction - Tera for templating. I am pretty happy with this stack for now. As an added challenge I am trying to not use javascript or a css library until I feel it's necessary.

I have a working CRUD, with pagination and now I am working on adding a search bar with filters (like only searching names, or another specific column, by date, etc), and in the list of items letting the user order the items by the columns.

In the future I want to add more functionality like adding items in bulk instead of going to the specific items and adding there (this could become a sales order in the future), user management with permissions, auth and more.

I am having fun, learning some nice css tricks here and there, how to get info from the user using forms, implementing light and dark mode using cookies.

I do wonder in the future when I try to make harder queries (like for filters or for reports with more complex conditions) I'll have to change diesel for rusqlite.

Cool project! I was actually looking for some such – actually a symbol mesh. But probably a file- or directory-mesh would already be overwhelming.

I was intrigued how you used Stringlet, but couldn’t find that code. Since one of your main tasks is dealing with file names, which can be verrrrrry long, I’m not sure that it would be a good match.

Yeah, so I haven't actually put Stringlet to use yet. The potential spot was output formatting — strings with colors. But in the end I managed to do without strings there altogether. So I still haven't found a place to stick Stringlet in my code. But, as I said, that's more about the specifics of my projects. I've got a couple more web services in Rust — I think it should come in handy there.

Been working on a tailscale-rs port for ESP32 (RISC-V): https://github.com/alanjds/tailmicro-rs

The official lib blows up on the ~300kb memory of ESP32 chips, so I had to juggle some parts, join some tasks instead of spawning them, mess with the TLS requirements and so on.

Took a lot of work and "inspiration" from the Microlink (C lib) & tsnet (Go lib) to fill the gaps of tailscale-rs, but in the end it currently works reasonably well! Why: Am doing a "port" of Tasmota and WLED features & APIs for my personal needs, planned to be publised soon (tm).

Comments, issues and forks are very welcome

Creating a development framework :rofl:

It is not web framework, but just framework, for developing high performance app in Rust

It is Rust no_std + custom high performance focused standard library

Currently consist of :

  • high performance allocators (big virtual address arena and double ended variant, general purpose allocator)
  • ergonomic high performance error handling, small size enum
  • SSO String (pointer to rodata for initial value, the pointer points to heap only if the value grow dynamically, same type so it can be used in single same Array and Vector)
  • QSBR RCU and Hazard pointer (to replace Arc Mutex RwLock)
  • Read only QSBR and Hazard pointer (to replace Arc reference counting)

Many more high performance tools are incoming :rofl:

Here are the some performance demo :

String is 9x faster than STD String

That are :

  • STD String
  • SSO String, pointer to rodata, fallback : pointer to heap by general purpose allocator
  • Non SSO Custom String, pointer to heap by big virtual address arena allocator
  • SSO String, pointer to rodata, fallback : pointer to heap by big virtual address arena allocator

The QSBR RCU and Hazard pointer are 2-3x faster than STD Arc Mutex, RwLock, and including the variant from ParkingLot library

Read only QSBR is 9x faster than STD Arc. Read only Hazard pointer is 11x faster than STD Arc. Tested in 4 threads, 1 million reads

The non deferred will block main thread on out of scope. The deferred variant will not block main thread and without async

I created this because the STD is not performance focused, for example STD String won't has SSO optimization because the reason stated in its documentation, because I don't need that reason so I create my SSO String because wasting SSO optimization is very waste when I don't even need the reason stated in STD String documentation