bnto

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.

---

Recipes

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

Build Your Own

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.

---

How It Works

CLI

# 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 doctor

The 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.

Interactive TUI

# Launch the interactive terminal UI
bnto tui

# With a dark theme
bnto tui --theme tokyo

# Golden-hour sunset theme
bnto tui --theme monaco

The 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).

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.

The .bnto.json Format

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.

---

The Bento Box

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.json files.
• 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.

---

Where This Is Going

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.

---

For Developers

Prerequisites

• Node.js 18+
• pnpm
• Task
• Rust toolchain (for engine work, install via rustup)

Setup

git clone https://github.com/Develonaut/bnto.git
cd bnto
pnpm install

Commands

# 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)

Architecture

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).

Repository Structure

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)

---

Contributing

Contributions are welcome. To get started:

1. Fork and clone the repository
2. Install prerequisites (Node.js 18+, pnpm, Task, Rust)
3. Run pnpm install to set up dependencies
4. Run task dev to start the development servers
5. Run task check before submitting a pull request

Follow the existing code patterns and the Bento Box Principle: small, focused files and functions with clear boundaries.

---

Support

If bnto saves you time, consider buying me a coffee.

License

MIT - Copyright 2024-2026 Develonaut