DEV Community: Vlad B.

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

Vlad B. — Thu, 17 Sep 2026 02:09:44 +0000

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.

VladB-evs / Fuse

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

Fuse

Visual Command & Workflow Builder for macOS

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

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

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}}"

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:

Download the latest release from GitHub Releases.
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

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!

This week at Romi #2 - Latency and Voice AI

Vlad B. — Tue, 08 Sep 2026 04:23:59 +0000

Welcome back to ~~This~~ Last week at Romi. We've been really busy so this post hits a bit late than our scheduled Friday one!

In Voice AI, saving 200–300 milliseconds sounds tiny on paper. In practice, it’s the difference between an awkward robotic delay and a natural conversation.
This week, we took a hard look at our pipeline to eliminate latency and clean out old code that was getting in the way. Here is what we changed:

Sync to Async Tools: Originally, tool execution was synchronous. When a user created a task, the pipeline froze waiting for database writes. Making our tools asynchronous means the voice keeps flowing naturally while items are saved in the background.
7 Dedup Layers Down to 2: To stop duplicate tasks from hitting the database, we kept piling on safeguards over time until we had 7 layers of deduplication. They slowed down the pipeline and began contradicting each other. With stronger prompt reinforcement and a quick backend cleanup, we cut that down to just 2 layers.
Ditching "Thinking" Models: Since our agent relies heavily on fast tool calls, thinking models added unnecessary reasoning delay before speaking. We swapped to a model optimized strictly for speed and accurate tool invocation.
Push-to-Talk Toggle: To complement these backend speedups, we added a toggle between Natural Flow and Push-to-Talk. Now users can think out loud or speak in noisy rooms without the model prematurely triggering unwanted tasks.

Sometimes performance wins aren't about writing complex new code—they're about deleting redundant safeguards, running tasks in the background, and picking the right model for the job.

What's the worst bit of legacy "safety code" you've had to clean out of your stack?

By Vlad - CTO@RomiADHD

This week at Romi #1 - OTA updates

Vlad B. — Sat, 29 Aug 2026 06:21:04 +0000

We finally added OTA updates to Romi.

This is something apps have been doing for years, but it’s new territory for us.

Instead of waiting for Apple’s review every time we need to push a small fix, we can now ship certain updates directly to users.

And because apparently paying for another service wasn’t exciting enough, we built our own setup using Capgo + CDN.

It’s one of those things that feels obvious once it works. Getting there was slightly less obvious. 😅

What’s something your team implemented way later than everyone else?

By Vlad - CTO@RomiADHD

I Built an Obsidian Plugin for Myself. Someone Actually Used It.

Vlad B. — Sat, 29 Aug 2026 04:26:47 +0000

I got an email recently from someone asking if I could add a feature to one of my Obsidian plugins.

The funny part? I built the plugin for myself and never really expected anyone to use it.

The plugin adds folder backlinks to Obsidian, since Obsidian only supports backlinks to notes.

He asked if I could make folder links work inside note properties because he couldn't figure out how to do it himself.

So I built it.

It's now a two-step command palette action: select the folder, then select the note property, and the link gets added.

While I was working on it, I also found a few things that weren't as smooth as they should be, fixed a couple of bugs, and polished some of the rough edges.

It's kind of weird seeing someone use something you built purely because you wanted it yourself.

Maybe I should start taking my side projects a little more seriously.

Hello from Romi!

Vlad B. — Thu, 27 Aug 2026 04:51:57 +0000

Hey this is Vlad, the CTO. We’ve been quietly building Romi for a while, so we figured it was probably time to stop hiding in the codebase.

Romi thinks like you do. Voice-first, ADHD-first. Capture thoughts, build routines, and actually stick to them. Your brain deserves a companion that keeps up.

I'm not trying to promote anything but to share what we’re building, the things we learn along the way, technical decisions, experiments, and probably a healthy amount of “well, that broke.”

We’re especially interested in exploring what happens when AI becomes something you actually work with every day, rather than just another chatbot in a browser tab.

If you’re building with AI, working on developer tools, or just enjoy watching other developers make questionable architectural decisions, welcome.

Ask me anything in the comments.

I Finally Joined DEV.to

Vlad B. — Thu, 27 Aug 2026 04:10:55 +0000

Well, I finally joined DEV.to.

Got bored of social media and scrolling so I decided to give this a go and scroll some more.

I’m currently working on Romi, experimenting with AI agents, and finding increasingly questionable ways to make computers do what I don't want to do.

I’ll probably post about what I’m building, cool open source stuff I find and maybe show off some of my (not so great) side projects.

Anyway, If you saw this tell me your best programming joke that will kill on slack lol 🗿