DEV Community

Vlad B.
Vlad B.

Posted on

What If Your Terminal Had an Infinite Canvas? Meet Fuse.

#opensource #macos #rust #productivity

Let’s be honest: every software project eventually grows a collection of messy, fragile shell scripts.

You know the drill:

  • A 200-line release script that occasionally breaks mid-execution.
  • Juggling three terminal tabs to run migrations, build artifacts, bump versions, and deploy across different sub-projects.
  • Forgetting a parameter or copy-pasting an API token into the wrong prompt.

I wanted something that gave me the visual clarity of node-based automation tools (like Blender shader graphs or visual CI pipelines), but running 100% locally on my Mac, with zero cloud lock-in, and without an Electron app eating 1GB of RAM.

So I built Fuse — an open-source, native visual command and workflow builder for macOS.

GitHub logo VladB-evs / Fuse

Visual command and workflow builder for macOS. Connect shell commands, scripts, APIs, Git operations, and logic into executable workflows.

Fuse Logo

Fuse

Visual Command & Workflow Builder for macOS

Release Platform Built with Tauri Rust License

Draw your terminal commands as connected blocks on an infinite canvas.
Orchestrate complex shell scripts, APIs, git workflows, and automated pipelines with real-time streaming output, smart variables, and Apple on-device intelligence

Key Features • Quick Start • Block Catalog • Variables & Flow • Shortcuts • Architecture


Fuse Canvas Interface

(the actual image of the worlflow used for this app)


⚡️ Key Features

  • 🎨 Fluid Canvas Orchestration — Built for speed. Add blocks with a keystroke, drag wires between ports, and let frames auto-resize around their contents.
  • 🦀 Native Rust Performance — Zero Electron bloat. Powered by Tauri 2 and Tokio async DAG walk. Sub-50MB memory footprint with instant launch times.
  • 🧠 Apple On-Device Intelligence — Analyze git diffs locally using on-device semantic summaries to generate conventional commit messages in milliseconds.
  • 📁 Repository & Folder Frames — Group blocks inside folder frames. Every block inside…
View on GitHub

What is Fuse?

Fuse lets you draw terminal commands, scripts, and API calls as connected nodes on an infinite canvas. You connect blocks with wires, pass variables downstream, set up conditionals, and watch real-time streaming ANSI terminal outputs as your DAG (Directed Acyclic Graph) executes.

Fuse Canvas Interface

Why Not Just Run Shell Scripts?

Here is what makes workflow graphs in Fuse fundamentally different from chaining && in a terminal:

1. Multi-Repo "Folder Frames"

Working on a monorepo or separate client/server repositories? You can drop a Folder Frame on the canvas and bind it to a local directory. Any block placed inside that frame automatically executes within that directory. You can coordinate your backend, frontend, and Docker setups on a single screen.

2. Smart Variable Piping (Without Escaping Nightmares)

Outputs from upstream blocks are automatically captured and bound into your workflow context:

  • Upstream: git rev-parse --short HEAD -> {{sha}}
  • Upstream: Semantic version bumper -> {{next_version}}
  • Downstream: Use them in curl payloads, shell commands, or commit messages: 
git commit -m "chore(release): bump to {{next_version}}"
git tag "{{next_version}}"
Enter fullscreen mode Exit fullscreen mode

Fuse handles shell-safe escaping under the hood so spaces, quotes, and multiline inputs won't break your commands.

3. Human-in-the-Loop Controls

Workflows shouldn't always be a blind "run and pray":

  • Confirm: Pauses execution and asks for approval before critical actions (like git push --tags or a production deploy).
  • Ask: Prompts you mid-run for a one-time value or secret token (with password masking).
  • Choose & If (Condition): Branch your execution paths dynamically based on exit codes or interactive user selections (e.g. [Deploy Staging] vs [Deploy Production]).

4. The "Laser Slicer" (Because UX Matters)

Instead of meticulously clicking wires to delete them, hold Ctrl and slice your cursor across connections or nodes like a laser blade to sever them instantly.

5. Native Rust Performance (Sub-50MB RAM)

Fuse is built on Tauri 2 and Rust with Tokio async processes. It starts up instantaneously, doesn't spin up heavy Chromium browser instances per window, and uses virtually no background idle resources.

The Block Catalog

Fuse comes with a modular set of blocks you can place with a single keypress (Tab or A):

Category Blocks
Execution Command (shell), Script (multi-line Python/Node/Bash), HTTP Request (REST calls)
Git & Release Bump Version (SemVer major/minor/patch), Git Presets (Init, Rebase, Tag, Push)
Data & Files Capture (stdout to variable), Set Variable, Read File, Write File, Ask (user input)
Flow & Logic If (Condition), Choose, Confirm, Wait (delay or healthcheck polling), Frame

Tech Stack

Under the hood, Fuse is built with modern web and systems tech:

  • Frontend: React 19, TypeScript, @xyflow/react (React Flow), Tailwind CSS v4, Lucide Icons.
  • Backend / Desktop Shell: Tauri 2 + Rust.
  • Runtime: Tokio asynchronous process groups, streaming ANSI terminal output with 256-color support.

Try It Out!

If you are on macOS (Apple Silicon or Intel), you can grab the pre-built .dmg directly from GitHub Releases:

  1. Download the latest release from GitHub Releases.
  2. Open the .dmg and drag Fuse.app into your Applications folder.

(Note: As an open-source release without an Apple Developer certificate, if Gatekeeper gives you a prompt, run xattr -cr /Applications/Fuse.app or right-click the app and choose **Open).

Or Build from Source: 

git clone https://github.com/VladB-evs/Fuse.git
cd Fuse
npm install
npm run tauri dev
Enter fullscreen mode Exit fullscreen mode

I’d Love Your Feedback!

Fuse is completely open source under the MIT License.

⚠️ A Quick Note: Early Beta & Use at Your Own Risk

Because Fuse executes real shell commands, scripts, and file operations directly on your local system with your user permissions:

  • This is an early active beta (v0.1.x): Expect bugs, UI rough edges, and evolving features as the project matures.
  • Use at your own risk: Always double-check your connections and test commands (especially destructive operations like rm, file writes, or git resets) on test repositories or dummy files first.
  • Back up your work: Make sure critical code is committed and pushed before running new automated pipelines. Your bug reports and early feedback during this phase are hugely appreciated and will directly help shape the app!

Top comments (0)