Pack your workflow.
Workflow automation through composable parts. Build a node for anything: image processing, data transforms, API calls, video downloads, shell commands. Chain nodes into recipes that automate your workflow. One Rust engine that compiles to native binaries, WebAssembly, and (soon) desktop and server. Write a recipe once, run it anywhere.
# Run a predefined recipe
bnto run compress-images *.jpg
# Chain nodes into multi-step workflows
bnto run optimize-images-for-web photos/
# Any workflow you can describe, bnto can run
bnto run my-custom-pipeline data/Recipes are portable .bnto.json files: composable pipelines that run everywhere (CLI, browser, desktop, server).
Also runs in your browser: bnto.io. Same engine, compiled to WebAssembly. Files never leave your machine.
A recipe is a pipeline of nodes. Each node does one thing (compress, resize, rename, convert, download, call an API) and you chain them together into a workflow. Need something that doesn't exist? Build a node for it, and the engine takes care of running it everywhere.
Predefined recipes work out of the box:
| Recipe | What it does | Try it |
|---|---|---|
| Compress Images | Compress PNG, JPEG, and WebP images instantly in your browser. No upload limits, no signup. | bnto.io/compress-images |
| Resize Images | Resize images to exact dimensions or percentages. Free, no signup required. | bnto.io/resize-images |
| Convert Image Format | Convert between PNG, JPEG, WebP, and GIF formats instantly. Free, no signup. | bnto.io/convert-image-format |
| Rename Files | Batch rename files with patterns. Free, no signup required. | bnto.io/rename-files |
| Clean CSV | Remove empty rows, trim whitespace, deduplicate CSV data. Free, no signup. | bnto.io/clean-csv |
| Rename CSV Columns | Rename CSV column headers in bulk. Free, no signup required. | bnto.io/rename-csv-columns |
| CSV to JSON | Convert CSV files to JSON format with configurable delimiters. Free, no signup. | bnto.io/csv-to-json |
| Merge CSV | Combine multiple CSV files into one with header reconciliation. Free, no signup. | bnto.io/merge-csv |
| Optimize Images for Web | Resize, convert to WebP, and compress images for fast web loading. Free, no signup. | bnto.io/optimize-images-for-web |
| Generate Thumbnails | Resize images to thumbnail size, convert to WebP, and add a prefix. Free, no signup. | bnto.io/generate-thumbnails |
| Compress & Rename | Compress images and add a suffix so originals and compressed versions are distinguishable. Free, no signup. | bnto.io/compress-and-rename |
| Standardize CSV | Clean up messy CSV data and rename column headers in one step. Free, no signup. | bnto.io/standardize-csv |
| Strip EXIF | Remove EXIF metadata from images instantly in your browser. No upload limits, no signup. | bnto.io/strip-exif |
| Watermark Images | Add a logo or watermark to images. Position, size, and opacity are fully configurable. Runs in your browser, files never leave your machine. | bnto.io/watermark-images |
| Download Video | Download video or audio from URLs using yt-dlp. Supports YouTube, m3u8/HLS streams, and hundreds of sites. CLI/desktop only. | bnto.io/download-video |
| SVG to PNG | Convert SVG vector files to PNG raster images instantly in your browser. No upload limits, no signup. | bnto.io/svg-to-png |
| SVG to JPEG | Convert SVG vector files to JPEG raster images instantly in your browser. No upload limits, no signup. | bnto.io/svg-to-jpeg |
| Optimize SVG | Optimize SVG files by removing editor metadata, comments, and unnecessary elements. Runs entirely in your browser. | bnto.io/optimize-svg |
Don't see what you need? Build it. Compose nodes into custom recipes using the visual editor or write .bnto.json by hand. Any node you create automatically works on every target the engine supports: browser, CLI, desktop, server.
Open the editor at bnto.io/editor.
# Install
cargo install bnto
# Compress all JPEGs in a directory
bnto run compress-images photos/*.jpg
# Download a video
bnto run download-video https://www.youtube.com/watch?v=dQw4w9WgXcQ
# Browse available recipes
bnto list
# Show recipe details and dependencies
bnto info download-video
# Check external tool availability
bnto doctorThe CLI runs recipes using the native Rust engine. Direct native execution with full system access. Progress bars, colored output, and timing summaries keep you informed.
# Launch the interactive terminal UI
bnto tui
# With a dark theme
bnto tui --theme tokyo
# Golden-hour sunset theme
bnto tui --theme monacoThe TUI is a full interactive terminal interface for browsing, configuring, and running recipes. No flags or arguments to memorize. Pick a recipe, tweak parameters, select files, watch progress, see results.
6 screens, one flow:
| Screen | What it does |
|---|---|
| Browser | Browse and search all recipes. / to search, Enter to select |
| Detail | View recipe description, edit parameters inline |
| Picker | Browse filesystem, multi-select input files by type |
| Execution | Live per-file progress with elapsed timer |
| Results | Output file list with sizes, savings, open-in-finder |
| Settings | Switch themes, configure output directory |
3 themes from the Motorway palette: los-angeles (warm cream, default), tokyo (cool dark), monaco (golden sunset). Switch at runtime via the Settings screen (s from Browser).
Pick a recipe at bnto.io, drop your files, get results. Processing happens entirely in your browser using the same Rust engine compiled to WebAssembly. No server round-trips.
You drop files
→ Browser loads Rust/WASM engine in a Web Worker
→ Files are processed entirely in-browser
→ You download the results
Your files never touch a server. The browser IS the server.
A recipe is a portable JSON file that describes a pipeline of nodes:
{
"formatVersion": "1",
"nodes": [
{
"id": "input",
"type": "input",
"parameters": { "mode": "file-upload", "accept": ["image/jpeg", "image/png"] }
},
{ "id": "compress", "type": "image-compress", "parameters": { "quality": 80 } },
{ "id": "output", "type": "output", "parameters": { "mode": "download" } }
],
"settings": { "iteration": "auto" }
}The same .bnto.json runs in the CLI, browser, desktop, and server. Nodes are the building blocks: each one encapsulates a single capability. Recipes compose them into workflows. The engine handles execution, progress reporting, and error handling across every target.
bnto is named after the bento box: a Japanese lunch container where each compartment holds one thing, serves one purpose, and fits together into a complete meal.
That idea is the architecture:
- Nodes are compartments. Each encapsulates one capability: compress an image, call an API, run a shell command, download a video. Build a node for anything you want to automate.
- Recipes are boxes. Compose nodes into multi-step workflows. Portable, shareable, version-controlled
.bnto.jsonfiles. - The engine is the tray. One Rust codebase compiles to every target: native CLI binary, WebAssembly for the browser, native desktop app, server-side execution. A node you write today runs everywhere the engine runs, without changes.
- Boxes compose. A recipe can contain other recipes. One node or twenty, the mental model never changes.
Today: 18 predefined recipes running via CLI, interactive TUI, and browser. A visual editor for building custom recipes. Video download (yt-dlp), image processing, CSV transforms, SVG optimization, file operations, all from one tool. Free, unlimited, no account required.
Next: New node types (shell commands, HTTP requests, Excel), more file operations, recipe expansion. The node catalog grows; every addition is automatically available on every target.
Later: Desktop app (Tauri) for native local execution. Cloud execution for server-side nodes (AI inference, video processing). Community-contributed node types and recipes.
The vision: Any workflow you can describe as a sequence of steps, bnto can automate. Build the node, compose the recipe, run it anywhere. One Rust engine powering CLI, browser, desktop, and cloud, with recipes as portable .bnto.json files that work on every target.
git clone https://github.com/Develonaut/bnto.git
cd bnto
pnpm install# Development
task dev # Start web + Convex dev servers (Next.js on port 4000)
# Rust engine
task wasm:build # Build WASM crates (release, web target)
task wasm:test # Run Rust unit + WASM integration tests
task wasm:lint # Run clippy
task wasm:fmt # Format Rust code
# Native CLI
task cli:build # Build native CLI binary
task cli:test # Run CLI unit + integration + golden tests
# Frontend
task ui:build # Build all TS packages
task ui:test # Run TS tests
task ui:lint # Lint all TS packages
# E2E tests (requires task dev running)
task e2e # Run Playwright E2E tests
# Quality gate
task check # Full check (lint + test + build)bnto follows the Bento Box Principle: every file, function, and package does one thing well.
The Rust engine is the core, a single codebase that compiles to every execution target. Write a node once, and it runs everywhere the engine runs.
Rust Engine (single codebase, multiple targets)
│
├── Native CLI (bnto run, bnto list, bnto doctor)
├── WASM (browser, via Web Worker, same crates, same code)
├── Desktop (Tauri, planned, native Rust, no WASM overhead)
└── Server (cloud execution, planned, same engine, managed infra)
Node Crates (each domain gets its own crate)
├── bnto-image (compress, resize, convert, overlay, strip EXIF)
├── bnto-spreadsheet (clean, rename columns, merge, CSV to JSON)
├── bnto-file (rename)
├── bnto-vector (SVG rasterize, optimize)
└── bnto-shell (shell command execution, native-only)
@bnto/core is the transport-agnostic API layer. UI components never call backend services directly; they use core hooks that swap backends depending on runtime (browser, desktop, or cloud).
bnto/
├── apps/
│ └── web/ # Next.js on Vercel (bnto.io)
├── packages/
│ ├── core/ # @bnto/core: Transport-agnostic API
│ ├── ui/ # @bnto/ui: Motorway design system
│ ├── editor/ # @bnto/editor: Visual recipe editor
│ └── @bnto/
│ ├── auth/ # @bnto/auth: Cloud auth
│ ├── backend/ # @bnto/backend: Convex schema + functions
│ ├── form/ # @bnto/form: Schema-driven config forms
│ ├── nodes/ # @bnto/nodes: Engine-generated node catalog
│ └── registry/ # @bnto/registry: Recipe curation + discovery
└── engine/ # Rust engine (WASM + native CLI)
└── crates/
├── bnto-core/ # Core types, traits, progress reporting
├── bnto-engine/ # Pipeline executor + node registry
├── bnto-image/ # Image compression/resize/convert/overlay
├── bnto-spreadsheet/ # Spreadsheet clean/rename/merge/convert
├── bnto-vector/ # SVG rasterize/optimize
├── bnto-file/ # File rename
├── bnto-encode/ # Shared image format detection + encoding
├── bnto-shell/ # Shell command execution (native-only)
├── bnto/ # Native CLI binary + interactive TUI
└── bnto-wasm/ # cdylib entry point (single WASM binary)
Contributions are welcome. To get started:
- Fork and clone the repository
- Install prerequisites (Node.js 18+, pnpm, Task, Rust)
- Run
pnpm installto set up dependencies - Run
task devto start the development servers - Run
task checkbefore submitting a pull request
Follow the existing code patterns and the Bento Box Principle: small, focused files and functions with clear boundaries.
If bnto saves you time, consider buying me a coffee.
MIT - Copyright 2024-2026 Develonaut