It's about time that I did this, all these years of cobbling together and duplicating this code and now I've formalized it into a crate!

So, if you've been following my coding adventures, you know I'm a big fan of Rust. And like many developers, I often find myself needing a fast, reliable local database. Enter RocksDB – it's powerful, battle-tested (used by giants like Meta!), and integrates nicely with Rust thanks to the rocksdb crate.

But... here's the thing. While RocksDB is great, using it directly ofte...

You've got this awesome project you built internally. It started small, maybe lived in a giant monorepo, or perhaps its own repo that also accumulated some... internal peculiarities. Now, the time has come: you want to share it with the world! Open source it! 🎉

That initial excitement often hits a speed bump: how do you actually get just that project out without exposing the entire monorepo, confidential history, accidental secrets, or internal configurations? And maybe even trickier: once it's out, how do ...

You've been there. Need a new microservice, maybe a quick CLI tool. You remember that perfect template you stashed away, or maybe you grab one off GitHub. git clone, run the generator... npm install... FAILED. Or cargo build... FAILED. Dependencies drifted, build steps changed, the world moved on. The template lied. Template rot is real, and it wastes our time debugging boilerplate before we even write line one of our actual project.

I got seriously fed up with this cycle. I've automated the heck out of th...

C5Store for Rust

C5Store is a Rust library providing a unified store for configuration and secrets. It aims to be a single point of access for your application's configuration needs, consolidating values from various sources (like YAML files), handling secrets securely via built-in decryption, and allowing dynamic loading through providers.

The core idea is to simplify configuration management in complex applications by offering a hierarchical, type-aware, and extensible configuration layer.

Key Features

Precursor Post
Ever found yourself trying to sort a list of strings in Rust, only to realize that no single standard sorting method does exactly what you need? Maybe you have a mix of fixed-length identifiers like ULIDs alongside human-readable filenames with numbers?

// Desired Sort Order?
[
  "id-00000000000000000000000001", // Fixed length, zero-padded
  "id-00000000000000000000000002",
  "report_2.csv",                 // Variable length, numbers
  "report_10.csv"
]

Standard lexicographical sort (slice...

Ever needed to run a task repeatedly in your Rust application? Maybe it's sending out daily reports, cleaning up old data weekly using a CRON schedule, or checking an external service every few minutes? You might reach for a job scheduler. While building a recent project, I found myself needing exactly this, but the existing Rust landscape didn't quite fit the bill for the specific blend of features I wanted. So, naturally, I decided to build my own: TurnKeeper.

This wasn't just about reinventing the wheel (...

Yes, another application configuration library, but I assure you this is way better than any one of them out there. This is the Provider section of the Config Triad (Provision, Management, Provider).

C5Store is a comprehensive answer to the "what config library should I use for dynamic runtime configuration" question. Library is available here: https://github.com/normano/c5store

Why?

I've scoured around for configuration libraries in multiple languages and find them to be lacking in how they are defined, integ...

If you've ever built a server-rendered web application with Actix Web and the Tera templating engine, you know the rhythm of the development dance all too well:

1. Make a change to your .html template.
2. Save the file.
3. Go to your terminal, hit Ctrl+C.
4. Run cargo run.
5. Wait for the compile.
6. Go back to your browser and hit refresh.

This cycle is a productivity killer. It's a constant context switch that pulls you out of your flow. For years, developers in other ecosystems have enjoyed "hot reloading" or "live reload...

I'm thrilled to announce the release of C5Store 0.4.3, a major update to my Rust configuration management library. This release perfects a powerful new feature I'm calling Transparent Secret Deserialization and follows closely on the heels of another critical addition for production environments: first-class support for systemd Credentials.

You can grab the latest version now on crates.io:
cargo add c5store

For those new to the project, C5Store is a powerful, layered configuration library for Rust applicat...

I'm thrilled to announce the release of c5cli version 1.1.1, a significant update that brings a major improvement to how you interact with your configuration files. This release is all about ergonomics and power, directly addressing feedback to make encrypting and decrypting secrets more intuitive and flexible, especially in complex, real-world configurations.

The star of the show? A brand new, expressive path syntax for the encrypt and decrypt commands.

Let's dive in.

The Old Way: Simple, But Limited

Until...

• GitHub: excsn/ironwal

• Crates.io: ironwal

For a while now, I've been diving deep into the foundations of durable storage. Every high-performance database or distributed system eventually needs a Write-Ahead Log (WAL): that critical, append-only record that ensures your data survives a crash. I wanted one that was deterministic, multi-stream, and above all, "battle-tested" against real-world failures. I mostly wanted one without write amplication, typically I would just build a logical WAL on RocksDB with FIFO ...

Precursor post:https://www.normansoven.com/post/a-pluggable-workflow-engine-is-something-always-been-promised-never-delivered

I DELIVERED BABY!

For the longest time, I've had this itch. You know the one – that recurring problem you see in project after project, the one you know there has to be a better way to solve. For me, that's been orchestrating those complex, multi-step business processes that are the backbone of almost any real-world application.

Think about it: user signup isn't just "create a database ...

GitHub | Crates.io

Orka is an asynchronous, pluggable and type-safe workflow engine for Rust, designed to orchestrate complex multi-step business processes with robust context management and conditional logic. It simplifies the development of intricate, stateful workflows by providing a clear structure for defining steps, managing shared data, handling errors consistently, and enabling dynamic execution paths, thereby improving code organization and maintainability for complex operations.

Orka 0.2.0 is...

rzmq 0.5.24: crates.io | Github - Async, Pure Rust ZeroMQ with Leading Performance on Linux

After some experimenting, I found that io uring was maxed out on a single thread meaning multiple connections could saturate it, so it's been a long time coming, io_uring sharded workers is here! Yes, rzmq's io_uring is no longer one single thread, it's multiple threads now and meets or beats Tokio in throughput.

I knew there was always more throughput on the table because Tokio could do it and I always had a plan to h...

Github | crates.io

RockSolid 3.0.0 brings a dependency update.We are now using rust-rocksdb with minimal changes needed. Enjoy the same API with updated underlying RocksDB 11 library.

Since the last RockSolid post, RockSolid has added TransactionDB, OptimisticTransactionDB, a more user friendly Iterator API that allows skipping.

rocksdb crate has not been published to for a year while the underlying rocksdb advances in version. RocksDB embedded has from 10 to 11 since the last time rocksdb crate was published....

When I announced Snapfire 0.4.0, the pitch was about the development loop: stop restarting your server every time you touch an .html file. That part hasn't changed, and it still works the same way.

This release is about the engine underneath.

Tera 2 shipped and it isn't a version bump. It's a rewrite. The Rust API changed, the template language changed, and a handful of things that used to fail silently now fail loudly. Snapfire 0.5.0 moves to it.

Today I'm releasing Snapfire 0.5.0.

GitHub Repository: https:/...

TL;DR: TypeScript + modern CSS, compiled straight to browser-ready ES modules,  no node_modules, no package.json, no bundler chain.

I just created and released Snapfire Compiler (snapfirec), a tiny Rust binary that turns your .ts + .css into browser-friendly .js and optimized .css, fast and predictable.

The problem (short)

TypeScript is fantastic, but the ecosystem isn’t. What should be a tiny, portable vanilla-JS library too often becomes a 200 MB node_modules mess, a dozen build plugins, and a bundler con...

Sometimes the stars align!

There is no Node.js in this stack. Not at build time, not at request time, not in the container. The build is a Rust binary, the server is a Rust binary, and the thing you deploy is one file with no node_modules next to it.

You still write TypeScript. You write .tsx pages, a load function per route, actions, layouts, middleware, all of it in the shapes you already know from Next.js and Remix. That part is deliberately unremarkable. What is underneath it is not.

This is part of a l...

SnapFire FSR represents the next generation of Native Full Stack Runtimes that will power the Web.

• Official Website powered by SnapFire FSR: https://snapfirers.com/
• SnapFire FSR: https://snapfirers.com/fsr
• Docs Page Subsite: https://snapfirers.com/fsr/docs
• FSR Github Repo | FSR crates.io

PageSpeed for WWW | PageSpeed for Docs Subsite

Benchmarks - HIGH PERFormance Rendering vs Node's V8 and QuickJS.

You write React and TypeScript. What serves it is a Rust binary with no JavaScript engine inside it.

Not a N...