Every dev has been there - you save a file, switch to the terminal, run the tests, switch back. Save, switch, run, switch back. It's just constant friction that breaks your flow. watchr eliminates that loop entirely by watching your directories and running commands automatically the monent something changes.

What watchr Does

watchr is a Rust CLI tool that watches one or more directories for file changes and runs a command in response. You configure it once, either via a .watchr.toml or directly on the CLI, and it handles the rest. Save a file, whatever you've configured for that directory runs automatically. No switching, no manual re-runs.

How It Works Under the Hood

watchr uses notify-deboucer-full for efficient filesystem monitoring. The debouce window prevents multiple runs from triggersing when you save repeatedly in a short period. Commands are executed via sh -c so you can chain them with &&, use pipes, or run anything you'd normally type in a shell.

Installation

git clone https://github.com/mg4603/watchr.git
cd watchr
cargo build --release
# Binary will be at target/release/watchr

cargo install --path . 
# To install to local Cargo bin dir

Quick Start

watchr watch src/ --cmd "cargo test"

Filter by extension:

watchr watch src/ --ext rs,toml --cmd "cargo test"

Using a Config File

For anything beyond a single watchr, a .watchr.toml is the right move. Generate a template:

watchr init

Then edit it:

debounce_ms = 500

[[watcher]]
name = "tests"
dirs = ["src/", "tests/"]
ext = ["rs"]
command = "cargo test"

[[watcher]]
name = "lint"
dirs = ["src/"]
command = "cargo clippy"

Start watching:

watchr watch

watchr walks up the directory tree to find .watchr.toml automatically. You can also point it at an explicit path:

watchr watch --config ~/my-project/.watchr.toml

Get the Code

Full source at GitHub. If it save you a few hundred manual test runs, give it a star.

If you've ever recorded a screencast or a demo video, you've probably experienced this: you play it back and all you can hear is the hum of your pc, the fan in the background, or streetnoise bleeding through your window. Fixing it means either buying expensive equipment, building a makeshift soundproof setup, or just putting out bad audio and hoping nobody notices. None of these are good options. denoiser is a simple CLI tool that cleans your audio in one command.

What denoiser Does

denoiser takes your video file, builds a noise profile from a short sample of background noise at the beginning, and uses that profile to strip the noise from the entire recording. The result is cleaner audio without touching your recording setup.

How It Works Under the Hood

Under the hood, denoiser uses the noisereduce library to do the heavy lifting. It samples a configuration duration of audio from the start of your file, defaulting to the first 2 seconds, treats that as the noise floor, and applies spectral gating across the full track to suppress it. The --prop-decrease flag controls how aggressively the noise is reduced.

Installation

git clone https://github.com/mg4603/denoiser.git
cd denoiser
pipx install .

Basic Usage

denoiser denoiser input.mp4 output.mp4

That's it. Default work well for most recordings.

The Flags Explained

• --noise-reduce (default: 2.0): how many seconds from the start of the file are used to build the noise profile.
• --prop-decrease (default: 1.0): how aggressively noise is reduced. 1.0 is full suppression. If output sounds hollow or over-processed, try 0.7 or 0.8.

denoiser denoise --noise-duration 1.5 --prop-decrease input.mp4 output.mp4

Get the Code

The full source is on GitHub. If this saves you a reshoot, git it a star.

What I built

logsnap is a Python CLI tools that lets you tail mutliple log files in one place, filter output by keyword, and snapshot the results for later analysis. Instead of juggling three terminals, you run one command and see everything in one unified view.

Getting started

Clone the repo and install locally:

git clone https://github.com/mg4603/logsnap.git
cd logsnap
pipx install .

Initialize your config:

logsnap config init

This creates a config file at ~/.config/logsnap/config.toml. Edit it to point at your log files:

[sources]
files = [
    "/var/log/syslog",
    "/var/log/app.log"
]

Then run:

logsnap watch

Every line is timestamped and prefixed with its source file so you always know where output is coming from. When you see somthing worth saving:

logsnap snap

Snapshots export in either plain text or JSONL format - useful if you want to query them later.

How it works

No external file-watching library. logsnap opens each log file, seeks to the end, then polls for new lines every 100ms. New lines get timestamped, tagged with their source path, written to your terminal and buffered to a session file simultaneously. Simple, dependency-light, and easy to extend.

What's next

The code is on GitHub. Feel free to open an issue or submit a PR if you have ideas or run into bugs.