DEV Community: fj-dig

Super – An API-first, lightweight process orchestrator written in Rust (alternative to PM2/Supervisor)

fj-dig — Mon, 07 Sep 2026 14:39:20 +0000

Hey,

Like many of you, I've spent years managing long-running background processes on VPS and small servers (gateway proxies, background workers, edge collectors, local LLM inference scripts, etc.).

For years, the go-to choices have been PM2 or Supervisor:

PM2 brings the entire heavy Node.js runtime, which feels completely overkill on small instances or edge boxes just to keep a few binary scripts alive.
Supervisor is stuck in the ini/CLI era with Python overhead, making it notoriously painful to control programmatically from modern CI/CD pipelines or automated agents.
systemd is rock-solid, but it requires root, is Linux-only, and dynamically registering services via code has high friction.

To scratch my own itch, I built Super — a zero-dependency, API-first lightweight process orchestrator written purely in Rust.

Architecture: Clean Client-Daemon Split

Instead of a bloated all-in-one binary, Super follows a classic daemon/client architecture compiled into two static Rust binaries:

superd (Daemon): The silent background service running as a system daemon. It handles process lifecycle, health checks, automatic crash recovery, log streaming, and exposes a clean REST API & WebSocket.
super (CLI): A sleek terminal interface for developers. It doesn't fork processes directly; it's simply an official HTTP API client to superd.

Anything you can do via the CLI can be triggered seamlessly via standard HTTP requests from your CI pipelines, Python/Go scripts, or AI agents.

Highlights

Zero Runtime Overhead: Pure static Rust binaries. No Node.js, no Python, single-digit MB memory footprint.
Transactional Service Updates: Built-in transactional deployment (backup ➔ verify ➔ switch ➔ auto-rollback on failure) so updating a service doesn't feel like gambling.
Declarative Stacks: Manage stacks via simple TOML with dependency chains and health probes via super apply.
Built-in Audit Ledger: Complete causal event ledger tracking why a process restarted or changed states.
Health Probes & Real-time Logs: Native HTTP/TCP health checks, and live log tailing over WebSockets.

Quick Look

You can spin up a process in seconds:

# Add and auto-start a service
super add --name demo --autostart python3 -m http.server 8080

# Check status and health
super list

# Stream live logs
super logs demo --tail

Installation

You can grab precompiled binaries for Linux (x86_64/arm64), macOS, and FreeBSD directly from the GitHub Releases page.

Or inspect and run the install script (it automatically checks SHA-256 and registers the system service):

curl -fsSL https://github.com/schiplat/super/releases/latest/download/install.sh | sh

(Detailed manual setup guide is available in our Getting Started Docs).

Licensing & Road Ahead

The core (superd engine + super CLI) is 100% open source under the MIT License, completely free, and will stay that way without arbitrary limits. We also have an extensible plugin system in the works for advanced enterprise setups (like multi-tenant RBAC, Web Dashboard, and cgroup isolation).

The project is currently in public beta. I’d love to hear your thoughts, feedback, architectural critiques, or any edge-cases you run into!

GitHub: https://github.com/schiplat/super
Docs: https://super.docs.sconts.com/docs/

Open source: ImageKit, a Rust-based tool for batch image compression and watermarking.

fj-dig — Sat, 28 Jun 2025 09:46:11 +0000

ImageKit - https://github.com/hzbd/imagekit

ImageKit is a powerful, fast, and flexible command-line tool for batch image processing. Written in Rust, it leverages parallel processing to maximize performance, allowing you to effortlessly resize, control the quality of, and add highly customizable watermarks to entire directories of images.

🌟 Features

Batch Processing: Recursively processes all images (.jpg, .jpeg, .png, .gif, .bmp) in a specified input directory.
Smart Scaling:
- If only a width is provided, the height is calculated automatically to maintain the aspect ratio.
- If only a height is provided, the width is calculated automatically.
Quality Control: Use the -q or --quality flag (1-100) to fine-tune the output quality, balancing file size and visual fidelity. Set to 100 for the best possible quality.
Powerful Watermarking:
- Multi-language Support: Perfectly renders watermarks with mixed text, including Chinese, Japanese, Korean (CJK), and Latin characters.
- Highly Customizable: Add text watermarks in nine standard positions and freely set the font size.
- Custom Colors: Precisely control watermark color and opacity using hex codes (e.g., RRGGBB or RRGGBBAA).
- Intelligent Watermark Scaling: If the requested watermark is too large for an image, it is automatically scaled down to fit perfectly, ensuring it is never cropped.
⚡ Blazing Fast Performance: Utilizes the Rayon library to process images in parallel, taking full advantage of multi-core CPUs.
Cross-Platform: Compiles and runs on Windows, macOS, and Linux.

⚙️ Installation & Build

You will need to have Rust and Cargo installed.

Clone the Repository

git clone https://github.com/hzbd/imagekit.git
cd imagekit

Prepare Fonts
This tool uses a font fallback system for multi-language support. Please ensure the assets/ directory contains:
- Roboto-Regular.ttf (for Western characters)
- A font with CJK support, such as SourceHanSansSC-Regular.otf (Source Han Sans). You can download it from Adobe Fonts GitHub.
Build the Project
```
cargo build --release
```
Locate the Executable
After building, the executable will be located in the target/release/ directory.

🚀 Usage

Examples

Example 1: Add a watermark with mixed Chinese and English text

./target/release/imagekit \
    -i ./input_photos \
    -o ./processed_photos \
    --watermark-text "你好, World! - Test Watermark"

Example 2: Resize images and save at maximum quality

If you want to resize without quality loss for JPEGs, use --quality 100.

./target/release/imagekit -i ./input_photos -o ./processed_photos --width 1024 --quality 100

Example 3: Add an opaque black watermark (using default quality 85)

./target/release/imagekit \
    -i ./input_photos \
    -o ./processed_photos \
    --watermark-text "Confidential" \
    --watermark-color 000000FF

📋 Command-Line Options

Option	Flags	Description	Required/Optional	Default
Input Directory	`-i`, `--input-dir`	The source directory containing images to process.	Required	-
Output Directory	`-o`, `--output-dir`	The directory where processed images will be saved.	Required	-
Width	`--width`	(Optional) Resize image width. Scales proportionally if height is omitted.	Optional	Original width
Height	`--height`	(Optional) Resize image height. Scales proportionally if width is omitted.	Optional	Original height
Watermark Text	`--watermark-text`	(Optional) The text content for the watermark.	Optional	-
Watermark Position	`--watermark-position`	(Optional) The position of the watermark on the image.	Optional	`se`
Font Size	`--font-size`	(Optional) The font size of the watermark text in pixels.	Optional	`24`
Watermark Color	`--watermark-color`	(Optional) Watermark color in RRGGBB or RRGGBBAA hex format.	Optional	`FFFFFF80` (semi-transparent white)
Quality	`-q`, `--quality`	(Optional) Set output quality (1-100). Affects JPEG and PNG compression.	Optional	`85`

Available values for `watermark-position`:

nw: North-West, north: North, ne: North-East
west: West, center: Center, east: East
sw: South-West, south: South, se: South-East

🛠️ Development & Testing

If you'd like to contribute to the project:

Clone the repository and prepare the fonts.
Make your changes.
Run tests to ensure all functionality is working as expected:
```
cargo test
```

📜 License

This project is licensed under the MIT License.