DEV Community: Omar

I built a CLI snippet manager in Rust because I was tired of googling the same things

Omar — Mon, 13 Apr 2026 12:11:01 +0000

I have a habit. Every time I sit down to code I end up googling the same thing, how to center a div, the Rust test module boilerplate, docker run flags, ffmpeg commands. Every. Single. Time.

So I built sinbo, a CLI snippet manager that lets you store code once and retrieve it anywhere.

github: https://github.com/opmr0/sinbo

sinbo add docker-run -t docker        # save it once
sinbo get docker-run                  # get it anywhere
sinbo copy docker-run                 # or copy to clipboard

What it does

Snippets are stored locally as plain files in your config directory. No cloud, no account, no sync. Just files you own.

You can tag snippets, add descriptions, and filter by tag:

sinbo add nginx-conf -t infra server -d "default nginx config"
sinbo list -t infra
sinbo search "nginx"

Encryption

The feature I am most proud of, sensitive snippets like API keys and tokens can be encrypted at rest using AES-256-GCM with Argon2id key derivation.

sinbo add github-token --encrypt
sinbo get github-token   # prompts for password

The plaintext never touches disk. Only the .enc file is stored.

Variable placeholders

Snippets can contain placeholders using a custom SINBO:var: syntax:

# snippet content:
docker run -p SINBO:port: -it SINBO:name:

# usage:
sinbo get docker-run -a port=8080 name=myapp
# output: docker run -p 8080 -it myapp

Piping

Since sinbo get prints to stdout it composes naturally with other tools:

sinbo get deploy-script | sh
sinbo get query | psql mydb
sinbo get docker-run -a port=8080 | sh

Shell completions

Tab completion for snippet names works out of the box for bash, zsh, fish and powershell:

echo 'eval "$(sinbo completions bash)"' >> ~/.bashrc && source ~/.bashrc

Then sinbo get [TAB] shows your actual snippet names.

What I learned

This was my first time implementing real encryption in Rust. The aes-gcm and argon2 crates made it approachable but I still had to understand the underlying concepts to use them correctly. Building sinbo pushed me to actually learn AES-256-GCM, why nonces matter, and what Argon2id does.

Try it

cargo install sinbo

If you find this useful, drop a ⭐️ on GitHub

I built a TOML-based task runner in Rust

Omar — Sat, 28 Mar 2026 17:04:26 +0000

Every project I work on has the same problem. There's always a set of commands I run in the same order every time, setting up dependencies, building, running checks. I got tired of either remembering them or keeping a random notes file.

Makefiles work but feel wrong outside of C projects. npm scripts are JavaScript-only. just is great but it's another syntax to learn on top of everything else.

So I built xeq.

You define named scripts in a xeq.toml file and run them with one command:

[check]
run = [
    "cargo fmt --check",
    "cargo clippy -- -D warnings",
    "cargo test"
]

[build]
run = [
    "xeq:check",
    "cargo build --release"
]

xeq run build

That's it. No new syntax, just TOML that any project already understands.

It supports variables with fallback values, positional and named arguments, environment variables, nested script calls, parallel execution with thread control, and on_success/on_error event hooks.

The feature I'm most happy with is xeq validate, it catches undefined variables, missing nested scripts, circular dependencies, and parallel conflicts before you run anything.

There are also 30+ init templates so you can get started instantly:

xeq init rust
xeq init docker
xeq init nextjs

It works on Linux, macOS, and Windows.

Still early but functional. Would love feedback❤️

Repo: https://github.com/opmr0/xeq
Crates.io: https://crates.io/crates/xeq

I built a file watcher in Rust

Omar — Wed, 18 Mar 2026 21:11:40 +0000

You know the loop.

Save. Switch to terminal. Up arrow. Enter. Wait. Switch back. Repeat forever.

I got tired of it so I built fyr, a file watcher that kills the ritual.

The basics

fyr -w src -r "cargo run"

Save a file inside /src, fyr runs your command. Previous run still going? It kills it first. No stale processes, no duplicate output. Just a clean run every time.

Tasks system

fyr task add build -w src -r "cargo build --release"
fyr run build

Save it once, run it from anywhere. No more remembering flags.

You can also drop a fyr.toml in your project and commit it, so everyone on the team gets the same setup for free:

[tasks.build]
watch = ["src"]
run = "cargo build --release"

[tasks.test]
watch = ["src", "tests"]
run = "cargo test"

How it stacks up

Benchmarked against the popular alternatives:

Tool	Startup	Idle memory
fyr	219ms	7.6 MB
watchexec	238ms	13.5 MB
chokidar	501ms	37.6 MB
nodemon	528ms	41.2 MB

GitHub: https://github.com/opmr0/fyr

Would love to hear what you think, especially if you've used watchexec or cargo-watch before.