Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Welcome to BinaryCircuits

Version: 0.1.1-alpha | By MatrixForge Labs

BinaryCircuits transforms n8n workflows into fast, standalone Rust binaries. Instead of running a Node.js server or relying on cloud infrastructure, you compile your automations into native executables that run anywhere—no dependencies, no runtime costs, just pure performance.

Whether you’re a hobbyist automating personal tasks, a developer building products, or an enterprise managing large-scale workflows, BinaryCircuits gives you speed, portability, and complete control over your automation.

What is BinaryCircuits?

BinaryCircuits is a workflow automation platform that combines three powerful capabilities:

  1. Workflow Compilation – Transform n8n workflows (JSON) into compiled Rust binaries that execute 10-100x faster than interpreted workflows
  2. Curated Marketplace – Browse and purchase from 10,000+ pre-built, production-ready workflows covering everything from API integrations to AI pipelines
  3. Complete Tooling – TUI/CLI applications for browsing, purchasing, compiling, and managing workflows with built-in licensing and subscription support

You can use BinaryCircuits in three ways:

  • Use marketplace workflows – Purchase ready-made automations and run them instantly
  • Compile your own workflows – Bring your existing n8n workflows and compile them to binaries
  • Build new workflows – Use our AI-powered workflow builder and TUI editors (coming soon)

Why Compile Workflows?

Traditional automation platforms run workflows as interpreted code on a server. BinaryCircuits compiles them into native executables:

Performance

  • Compiled Rust code runs 10-100x faster than interpreted JavaScript
  • Minimal memory footprint (MBs vs GBs for full n8n instances)
  • Instant startup, no warm-up time

Portability

  • Standalone binaries with zero dependencies
  • Deploy anywhere: servers, containers, edge devices, Raspberry Pi
  • No Node.js, no databases, no runtime infrastructure needed

Security

  • Compiled binaries are harder to reverse engineer than JSON workflows
  • Credentials embedded at compile-time, not in plaintext files
  • Reduced attack surface (no dynamic script execution)

Cost

  • Own What You Compile – Run binaries forever with no ongoing fees
  • No per-execution costs, no API limits, no surprise bills
  • Pay for subscriptions (access to marketplace/compiler), not runtime usage

Control

  • Run completely offline after compilation
  • No vendor lock-in – your binaries work without BinaryCircuits servers
  • Self-hosted by default, cloud features optional

How It Works

┌─────────────────────┐
│  1. Choose Source   │
│  ├─ Marketplace     │  Browse 10k+ workflows
│  ├─ Your own n8n    │  Import existing workflows
│  └─ Build with AI   │  Generate new workflows (coming soon)
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│  2. Compile         │
│  ├─ Validate nodes  │  Check 172+ supported node types
│  ├─ Generate Rust   │  Create optimized source code
│  └─ Build binary    │  Compile for your platform
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│  3. Deploy & Run    │
│  ├─ Standalone      │  No dependencies needed
│  ├─ Licensed        │  Hardware-bound, offline validation
│  └─ Fast            │  Native performance
└─────────────────────┘

Offline Compilation (Free Tier)

  • Compile unlimited workflows on your machine
  • Access free marketplace workflows
  • No internet required after initial setup

Online Features (Paid Tiers)

  • Cloud compilation service (faster, no local build tools needed)
  • Premium marketplace workflows
  • Cloud storage for binaries
  • AI workflow builder
  • Priority support

Supported Workflows & Nodes

BinaryCircuits supports 172+ n8n node types across these categories:

Core Operations

  • HTTP Request, Code (JavaScript), Set, Merge, Switch, If, Webhook
  • Batch processing, error handling, loops

Databases & Storage

  • PostgreSQL, MongoDB, MySQL, Redis, Supabase
  • BigQuery, Snowflake, ClickHouse
  • Amazon S3, Google Drive

Business Integrations

  • Stripe, Pipedrive, Salesforce, HubSpot
  • Slack, Microsoft Teams, Discord
  • Gmail, Mailjet, SendGrid

AI & Machine Learning

  • OpenAI, Anthropic Claude, Google Gemini
  • Hugging Face, LangChain
  • MCP (Model Context Protocol) clients

Productivity & Tools

  • Google Sheets, Notion, Airtable
  • GitHub, GitLab, Jira
  • Spotify, Telegram, WhatsApp

Development Tools

  • Webhooks, Wait nodes, Human-in-the-Loop
  • Split in Batches, aggregations
  • Custom code execution via Rhai

All nodes in the marketplace are tested and production-ready. Nodes under development or requested by users are tracked separately and not yet visible in the TUI.

Who This Is For

Hobbyists & Personal Use

  • Automate personal workflows on Raspberry Pi or home servers
  • Run “set-and-forget” automations without cloud costs
  • Privacy-first: keep data on your own hardware

Developers & DevOps

  • Build automation products to sell to customers
  • Deploy workflows as microservices or CLI tools
  • Integrate compiled workflows into existing systems

Businesses

  • Replace expensive SaaS tools with self-hosted automation
  • Ensure compliance with on-premise deployments
  • Predictable costs (subscriptions, not per-run)

Enterprise

  • Large-scale workflow orchestration with monitoring
  • Hardware-bound licensing for security
  • Multi-region deployments with centralized control
  • Audit trails and governance

Pricing Model

BinaryCircuits uses a freemium subscription model:

TierPriceFeatures
Free£0Unlimited offline compilation, free workflows only
Hobbyist£5/mo or £50/yr50 cloud compiles/mo, hobbyist workflows, 1GB storage
Pro£15/mo or £150/yr200 cloud compiles/mo, pro workflows, 5GB storage
Business£120/mo or £1,200/yrUnlimited cloud compiles, all workflows, unlimited storage

Additional Options:

  • Pay-as-you-go credits for extra compiles or storage
  • One-time purchases for premium workflows
  • Enterprise contracts for custom deployments

Key principle: You pay for access and compilation, not execution. Once a workflow is compiled, it’s yours to run forever with no additional fees.

Development Status

BinaryCircuits is currently in alpha (0.1.1-alpha) and under active development. We’re targeting a production-ready beta release with:

✅ Available Now (Alpha)

  • Offline workflow compilation
  • User TUI for browsing and managing workflows
  • Admin TUI for enterprise management
  • License generation and validation
  • Core node implementations (172+ types)

🔄 Coming in Beta

  • Cloud compilation service
  • Full Stripe payment integration
  • 10,000+ tested marketplace workflows
  • AI-powered workflow builder
  • TUI workflow editor

📋 Roadmap

  • Visual workflow editor
  • Web dashboard (gRPC-Web)
  • Multi-platform installers (macOS, Windows)
  • Prometheus metrics and monitoring
  • Multi-region cloud deployments

While we’re releasing as beta to early adopters, the platform will be production-ready. You can use it for real workloads from day one.

What You’ll Learn in This Guide

This User Guide will teach you:

  1. Getting Started – Installation, first compilation, basic usage
  2. Core Concepts – How compilation works, licensing, workflows vs binaries
  3. Using the App – TUI navigation, browsing marketplace, managing library
  4. Working with Workflows – Importing, compiling, running, debugging
  5. Subscriptions & Licensing – Pricing tiers, license management, activation
  6. Support – Troubleshooting, FAQ, getting help

By the end, you’ll know how to browse the marketplace, compile workflows, manage subscriptions, and deploy binaries to production.

Not Covered in This Guide

This is the User Guide focused on using BinaryCircuits. For other topics:

  • System administration – See internal Admin Guide (not public)
  • Development & contributing – See internal Developer Guide (not public)
  • API reference – See internal API documentation (not public)

You don’t need to understand Rust, n8n internals, or system architecture to use BinaryCircuits effectively. This guide assumes no prior knowledge beyond basic command-line familiarity.

Ready to Start?

Head to the next section: Getting Started to install BinaryCircuits and compile your first workflow.

Questions? Check the FAQ or Get Support.

Getting Started

This chapter walks you through the essential steps to get your first BinaryCircuits‑compiled workflow up and running, whether you are:

  • Running a single workflow binary on your own machine, or
  • Using the BinaryCircuits user app and controller to manage multiple workflows.

You do not need to know anything about n8n internals or Rust to follow along.

System Requirements

Compiled workflows are highly portable and have minimal requirements:

  • A compatible operating system (Linux, macOS, or Windows).
  • Sufficient memory and CPU for the workload (most workflows are very lightweight; typical usage is similar to running a small CLI tool).
  • No external dependencies like Node.js, Python, or even an n8n instance are required.

If you use the user TUI/CLI or controller, you will also need:

  • A reasonably recent terminal emulator.
  • Network access from the TUI/CLI to the BinaryCircuits API (for login, marketplace browsing, etc.).

Two Ways to Use BinaryCircuits

There are two primary ways you will interact with BinaryCircuits:

  1. Direct binaries – you download a compiled workflow binary and run it like any other program. This offers maximum simplicity and self-containment.
  2. Managed workflows – you use the BinaryCircuits user app and controller to browse, install, and run workflows in a more automated and centralized way. This provides enhanced management and automation capabilities.

You can mix and match these approaches. Many users start with direct binaries, then move to the controller once they have a handful of workflows they rely on.

Option 1: Using a Downloaded Binary

When you acquire a workflow from the BinaryCircuits marketplace, you receive a single, executable binary file (and optionally a small README and metadata file that describes the workflow).

Step 1 – Download the Binary

From the BinaryCircuits marketplace or user app:

  • Choose the workflow you want.
  • Select the appropriate build for your operating system and architecture (for example: linux-x86_64, macos-aarch64, or windows-x86_64).
  • Download the binary file (for example, email-reporter-linux, email-reporter.exe).

Step 2 – Place It Somewhere Sensible

Move the file to a convenient location on your system. Common choices:

  • A dedicated ~/workflows/ directory.
  • A directory that is included in your system PATH, such as /usr/local/bin (Linux/macOS) or a tools folder on Windows that is already on PATH.

Step 3 – Make It Executable (Linux/macOS)

On Linux and macOS, you may need to give the file execute permissions. In a terminal:

chmod +x /path/to/your/email-reporter-linux

On Windows, the downloaded file will typically already be executable (for example, email-reporter.exe).

Step 4 – Run the Workflow

Most workflows can be run directly:

/path/to/your/email-reporter-linux

If a workflow expects input, it will either:

  • Prompt you interactively, or
  • Expect JSON input via standard input or a simple flag (for example, passing a JSON file path).

The exact behaviour for a given workflow is documented in its marketplace description. A typical pattern is:

cat input.json | /path/to/your/email-reporter-linux

The workflow will execute its logic and, if it produces an output, will usually print the result as a JSON string to the terminal. You can then:

  • Pipe the output into another tool.
  • Save it to a file.
  • Feed it into other systems.

Option 2: Using the BinaryCircuits User App

For day‑to‑day usage, especially if you manage multiple workflows, the BinaryCircuits user TUI/CLI is the recommended way to interact with the platform.

The user app runs in your terminal and lets you:

  • Log in to your BinaryCircuits account.
  • Browse and search the marketplace.
  • See details for each workflow (description, pricing, inputs/outputs, example usage).
  • Add workflows to a cart and purchase them (or claim free ones).
  • Download compiled binaries associated with your account directly through the app.

Typical Flow in the User App

  1. Launch the app

    tui_user   # or the equivalent launcher on your system

  2. Log in or register

    • Use the login/registration screen to authenticate with your email and password.
    • Your subscription tier determines which workflows you can access.

  3. Browse and search

    • Use the browse screen to filter by category (AI, DevOps, Finance, etc.).
    • Search for keywords like “Slack”, “invoice”, or “webhook”.

  4. Inspect a workflow

    • Open the workflow details screen to see:
      • A high‑level description.
      • What inputs it expects.
      • What outputs it produces.
      • Pricing and licence information.

  5. Acquire the workflow

    • Add it to your cart and check out, or claim it if it is free and your tier includes it.

  6. Download and Configure

    • From the app’s library or workflow details, you can:
      • Download the compiled binary to a local directory.
      • Optionally configure it to be managed and run by the controller (e.g., set up schedules or webhooks).

The exact keybindings and screens may evolve over time, but the core idea remains: the user app is your “front door” into the BinaryCircuits ecosystem.

Running Workflows via the Controller

For more advanced scenarios—such as scheduling, webhook triggers, or centralised monitoring—you will use the BinaryCircuits Controller.

Think of the controller as a small service that:

  • Knows where each compiled workflow binary lives.
  • Starts workflows when triggers fire (manual, HTTP, cron).
  • Collects exit status and basic logs for each run.

When to Use the Controller

Use the controller if you:

  • Want to expose a stable HTTP endpoint for a workflow (for example, as a webhook).
  • Need to run workflows on a schedule (every hour, once per day, etc.).
  • Want a single place to see which workflows ran, when, and with what result.

Basic Workflow with the Controller

  1. Start the controller

    controller   # binary name may differ depending on your packaging

    By default, it runs as a long‑lived process and exposes HTTP and/or gRPC APIs.

  2. Register or configure a workflow

    • You can register a workflow with the controller using the BinaryCircuits user app, or a dedicated CLI tool. This process typically involves telling the controller:
      • The path to your compiled workflow binary.
      • What kind of trigger it should listen for (manual, webhook, scheduled).
      • Any default input or configuration parameters the workflow needs.

  3. Trigger the workflow

    • From a CLI helper (for example, a n8n-trigger‑style tool):

      n8n-trigger my-workflow-id --input '{"user_id": 42}'

    • Or by calling the controller’s HTTP API from your own systems (for example, a POST to /api/trigger/{workflow_id}).

  4. Monitor the run

    • Use the controller’s APIs or future TUI integrations to:
      • Check whether a run succeeded or failed.
      • Inspect basic logs and output.

For production environments, the controller‑based approach is preferred because it centralises execution and simplifies monitoring.

Next Steps

Once you are comfortable running a single workflow, you can:

  • Explore the Core Concepts chapter to better understand workflows, nodes, and triggers.
  • Read the Pricing & Subscriptions chapter to choose the right tier.
  • Use the controller to start building a small “fleet” of workflows that automate different parts of your infrastructure or business.

Core Concepts

To get the most out of BinaryCircuits, it helps to understand a few core ideas about how workflows are structured, how they run, and how they are managed once compiled.

This chapter deliberately focuses on what you work with, not how it is implemented internally.

Workflows

A workflow is the highest‑level container for your automation. It represents a complete, end‑to‑end process, such as:

  • “Fetch new emails and post them to Slack.”
  • “Process new customer sign‑ups and add them to the CRM.”
  • “Run a daily AI report over yesterday’s sales.”

When you acquire a compiled binary from the BinaryCircuits marketplace, you are getting a single, executable workflow that encapsulates all of the nodes, connections, and logic from its original n8n design.

Workflow Identity & Versions

Every workflow in the marketplace has:

  • A human‑friendly name (for example, “AI Email Classifier”).
  • A unique identifier that the platform uses behind the scenes.
  • A version, so that improvements and bug fixes can be shipped without breaking existing deployments.

When you download or compile a workflow, the binary you receive corresponds to a specific version. You can continue to run that version as long as you like, even if newer versions are later published.

If a new version introduces features or fixes you want, you you would typically re-download or re-compile that updated version via the BinaryCircuits app and then deploy it in place of the old one.

Nodes

A node is a single building block within a workflow. Each node performs one specific action. Workflows are created by connecting multiple nodes together to form a sequence of operations.

Here are a few examples of nodes:

  • Read IMAP: Fetches emails from an email server.
  • HTTP Request: Makes a request to an external API.
  • Slack: Sends a message to a Slack channel.
  • Code: Executes a small piece of custom JavaScript or Python code.
  • Set: Creates or modifies data within the workflow’s memory.

When a workflow runs, data flows from one node to the next, with each node performing its action on the data it receives. The compiled binary takes care of orchestrating that flow; as a user, you do not need to manage individual nodes directly.

Inputs and Outputs

Each workflow exposes a logical input and logical output:

  • The input is the JSON data you provide when starting a run (for example, { "user_id": 123 }).
  • The output is the JSON data the workflow emits when it finishes (for example, a processed record, a summary, or a status object).

The expected inputs and outputs for any given workflow are typically detailed in its marketplace description or when inspecting the workflow within the BinaryCircuits application. Internally, nodes may have many intermediate inputs/outputs, but as a user you usually only need to care about the “entry” and “exit” of the workflow as a whole.

Triggers

A trigger is a special type of node that starts a workflow. It’s the entry point for the entire process. Common trigger types include:

  • Manual Trigger: The workflow starts only when you explicitly run it (for example, by running the binary in the terminal or pressing a key in the controller UI). This is the default for most compiled workflows.
  • Webhook Trigger: The workflow starts when an external service sends an HTTP request to a specific URL. With the BinaryCircuits Controller, the controller exposes this URL and starts the appropriate workflow binary when a request is received. This is used to integrate with services that support webhooks (like GitHub, Stripe, or Twilio).
  • Cron (Scheduled) Trigger: The workflow runs automatically on a predefined schedule (for example, every hour, or every Monday at 9 AM).

When you use the BinaryCircuits Controller, it is responsible for listening for these trigger events (such as webhook calls or scheduled times) and starting the appropriate workflow binary with the correct input.

Manual vs Automated Runs

  • Manual runs are ideal while you are testing and validating a workflow. You start runs by hand and inspect the output.
  • Automated runs are ideal once a workflow is stable and you want it to react to external events or time‑based schedules without human intervention.

You can start with manual runs and later connect the same workflow to webhooks or schedules via the controller without re‑writing it.

The Marketplace

The BinaryCircuits marketplace is where you discover, acquire, and manage workflows.

From a user perspective, the marketplace, typically accessed via the BinaryCircuits TUI/CLI app, gives you:

  • A catalogue of workflows organised by category (AI, DevOps, Finance, CRM, etc.).
  • Clear pricing per workflow (for one‑time purchases) and per subscription tier.
  • Information about what each workflow does, what it needs as input, and what it returns.
  • Ratings and metadata that help you decide whether a workflow is suitable for your use case.

Your subscription tier determines which workflows you can access without extra payment, and you can always purchase individual high‑value workflows separately if you prefer a one‑off model.

The Controller

The controller is an optional but powerful part of BinaryCircuits. It is a long‑running service that:

  • Keeps track of which compiled workflow binaries are available on a machine.
  • Starts these compiled workflows in response to triggers (manual, HTTP, cron).
  • Records basic information about each run (status, timing, often minimal logs).

You can think of it as the “automation host”:

  • Workflows themselves are compact, self‑contained binaries.
  • The controller is the system that knows when and why to run them.

You can run workflows without the controller (by executing the binaries directly), but using the controller makes it much easier to manage more than a couple of workflows in production.

Your Account, Tiers, and Limits

Your BinaryCircuits account ties together:

  • Your subscription tier (Free, Hobbyist, Pro, Business, Enterprise).
  • Your entitlement to workflows in the marketplace.
  • Your compilation or download quotas where applicable.

Key points:

  • Free users can experiment with a generous selection of workflows and a limited number of compilations per month.
  • Paid tiers increase both access (more workflows, higher‑value categories) and capacity (more compilations, better support).
  • Compiled binaries you create or download remain usable even if you change or cancel your subscription; the quotas apply to new compilations or downloads.

The Pricing & Subscriptions chapter goes into these details, but conceptually it’s helpful to remember:

Your subscription controls what you can access and how much you can compile or download, not whether already‑compiled binaries continue to run.

Putting It All Together

From a user’s perspective, the BinaryCircuits “mental model” looks like this:

  1. You browse the marketplace for a workflow that solves your problem.
  2. Your account and subscription determine whether you can access it freely or need to purchase it.
  3. You download or compile the workflow binary.
  4. You run it either:
    • Directly from the command line, or
    • Via the controller, which handles triggers, scheduling, and monitoring.

You never need to interact with the underlying codebase or internal services to benefit from this model; those are intentionally hidden behind a simple, predictable user experience.

Using the BinaryCircuits App

This chapter explains how to use the BinaryCircuits terminal app (TUI) as an end user. The aim is that you can install it, log in, browse the marketplace, purchase workflows, and manage your library without needing separate support.

You do not need to know anything about Rust or the internal services to follow this guide.

Starting the App

Once you have installed the BinaryCircuits user application (typically a standalone executable named tui_user), you can start it from your terminal:

tui_user

If tui_user is not found, ensure it’s in your system’s PATH or specify the full path to the executable.

You will see:

  • A login / registration screen on first run.
  • A simple navigation bar that lets you switch between:
    • Browse – see workflows in the marketplace.
    • Search – (future) search by keyword.
    • Cart – view and manage workflows you plan to purchase.
    • Library – view workflows you own (once implemented).
    • Account – view your tier and licences (once implemented).

The exact keybindings are shown in the footer at the bottom of each screen, but the core navigation is consistent:

  • q or Esc – quit the app (or exit confirmation dialogs).
  • Number keys 1–5 – jump to main sections (Browse, Search, Cart, Library, Account) where enabled.
  • b or Backspace – go “back” from details to the previous screen.

Logging In and Registering

On the login screen you can:

  • Log in with an existing email and password.
  • Register a new account if you do not have one yet.

Switching Between Login and Register

  • Press Tab to toggle between Login and Register modes.
  • The form fields update to show what is needed (email, username, password).

Moving Between Fields

  • Use the arrow keys:
    • ↑ and ↓ to move between fields (Email, Username, Password).

Entering Your Details

  • Type as you would in a normal text field:
    • Characters appear in the active field.
    • Backspace deletes the last character.

Submitting the Form

  • Press Enter to submit either the login or registration form.
  • The app will:
    • Contact the BinaryCircuits API.
    • Create an account (for registration) or verify your credentials (for login).
    • Store a session file at ~/.matrixforge/session.json so you stay logged in next time.

If login/registration succeeds:

  • You are taken straight to the Browse screen.
  • Your subscription tier is stored in the session and used to determine which workflows and prices you see.

If there is an error (wrong password, connection problem, etc.):

  • An error message appears at the bottom of the screen.
  • You can correct the fields and press Enter again.

Logging Out

From any screen where a logout option is available (e.g., in the footer or Account screen), you can use it to securely end your session.

If you ever need to manually clear your session data, for example, if you are experiencing persistent login issues or need to log out from all devices, you can delete the session file:

rm ~/.matrixforge/session.json

Browsing the Marketplace

After logging in, you will usually start on the Browse screen.

The Browse screen shows:

  • A paginated list of workflows, with each item displaying:
    • Name.
    • Price in £GBP.
    • Tier (for example, Free, Hobbyist, Pro).
    • Category.
    • Node count and complexity score.
    • Average rating and number of reviews.
    • Whether the workflow is ready to be compiled (“Compilable ✓”).

Interpreting Workflow Information

  • Node count and complexity score: Generally, a higher node count and complexity score indicate a more intricate workflow, potentially offering more powerful or specialized automation.
  • Average rating and number of reviews: These help you gauge a workflow’s quality and reliability based on community feedback.
  • ↑ / k – move selection up.
  • ↓ / j – move selection down.
  • PageUp – go to the previous page.
  • PageDown – go to the next page.
  • Enter or v – view details for the selected workflow.
  • a – add the selected workflow to your cart.
  • 3 – jump to the Cart screen.
  • q – quit the app.

If you encounter issues connecting to the marketplace, ensure your internet connection is active. If problems persist, please contact support.

Viewing Workflow Details

From the Browse screen:

  • Select a workflow and press Enter or v to open the Workflow Details screen.

The details screen shows:

  • Name and price.
  • Tier and category.
  • Rating and number of reviews.
  • Number of nodes and complexity score.
  • A description of what the workflow does.
  • A list of key node types used.
  • Whether the workflow is compilable and the approximate binary size.

Key actions:

  • a – add the workflow to your cart (if you have not already).
  • p – add to cart and jump straight to the Cart screen.
  • b or Backspace – go back to Browse.
  • q – quit the app.

Use this screen to decide whether a workflow matches your needs before purchasing.

Using the Cart

The Cart screen shows all workflows you plan to purchase.

From Browse or Details:

  • Press a to add a workflow to your cart.
  • Press 3 to go directly to the Cart.

In the Cart screen you can:

  • See each workflow name and price.
  • See the total amount in £GBP.

Navigation and actions:

  • ↑ / k – move up through items.
  • ↓ / j – move down through items.
  • d or Delete – remove the selected item.
  • Ctrl+C – clear the entire cart.
  • Enter or p – proceed to checkout.
  • b – go back to Browse.

Checkout Flow

When you press Enter or p:

  1. A confirmation dialog appears showing:
    • Number of workflows.
    • Total price in £GBP.
    • Your current subscription tier.
  2. Press y or Enter to confirm, or n/Esc to cancel.
  3. On success:
    • Licences are created for each workflow.
    • A success dialog appears summarising the purchase.
  4. From the success dialog:
    • Press Enter or l to go to Library (once implemented).
    • Press b to go back to Browse.

If the API reports an error (for example, payment failure), the error text is shown and the cart remains unchanged so you can try again later.

Library and Account Screens (Upcoming)

The app will soon include fully functional:

  • Library:
    • This screen will display all workflows you own, allowing you to filter by compilation status and view basic runtime information.
    • You will be able to manage your downloaded and compiled binaries from here.
  • Account:
    • This screen will show your current subscription tier, basic account information, and a list of active licences tied to your account.

In early versions, these screens may show “Not yet implemented” messages as their functionality is being finalized. For now, your purchases and licences are securely stored and enforced on the server side.

Keyboard Shortcuts Summary

For quick reference, and as always, remember to check the help text in the footer of the current screen as it always summarises the most important keys for that specific context.

  • Global

    • q, Esc – quit.
    • b, Backspace – back to previous screen or browse.
    • 1–5 – jump between main sections (Browse, Search, Cart, Library, Account) where implemented.

  • Login/Register

    • Tab – toggle login/register mode.
    • ↑ / ↓ – move between fields.
    • Enter – submit.

  • Browse

    • ↑ / k – move up.
    • ↓ / j – move down.
    • PageUp / PageDown – change page.
    • Enter / v – view details.
    • a – add to cart.

  • Details

    • a – add to cart.
    • p – add to cart and go to cart.
    • b – back to browse.

  • Cart

    • ↑ / k, ↓ / j – navigate items.
    • d / Delete – remove selected item.
    • Ctrl+C – clear cart.
    • Enter / p – checkout.
    • b – back to browse.

Working With Workflows

This chapter focuses on what happens after you have purchased workflows: downloading, compiling (if needed), and running them in your own environment.

It is written for end users and power users, not developers. You will not need to modify code or internal services.

From Purchase to Binary

When you purchase a workflow:

  1. A licence is created for your account.
  2. You gain the right to compile and run that workflow (according to your subscription tier and licence).
  3. You can either:
    • Download an already‑compiled binary (if the platform offers pre‑built binaries for your OS), or
    • Trigger a compilation to produce a fresh binary for your target environment.

Exactly how this appears depends on your deployment (web UI vs TUI vs CLI), but the basic flow is the same: you end up with a single executable file per workflow.

Downloading a Binary

From your Library (once implemented) or web UI:

  • Choose the workflow.
  • Select the build for your platform (for example, Linux x86‑64, macOS Apple Silicon, Windows 64‑bit).
  • Download the binary file (for example, my-workflow-linux, my-workflow.exe).

Keep track of:

  • Which environment the binary is for (development, staging, production).
  • Which version of the workflow it corresponds to (new releases may contain bug fixes or improvements).

Running a Binary Directly

Once you have a binary:

Linux/macOS

  1. Make it executable (if it is not already):

    chmod +x /path/to/your/my-workflow-linux

  2. Run it:

    /path/to/your/my-workflow-linux

  3. Provide input if required:

    • Some workflows run with default settings and no input.

    • Others expect JSON input on standard input:

      cat input.json | /path/to/your/my-workflow-linux

    • Workflow‑specific documentation will tell you what shape the input JSON should take.

Windows

  1. Double‑click the .exe to run it, or run it from PowerShell/cmd:

    .\my-workflow.exe

  2. If the workflow expects input via standard input, you can use PowerShell:

    Get-Content input.json | .\my-workflow.exe

Output

Most compiled workflows write their output as JSON to standard output:

  • You can view it directly in the terminal.

  • Or pipe it into another tool or save it to a file:

    /path/to/your/my-workflow-linux > output.json

Using the Controller (Optional)

For more advanced setups, you can run workflows through the controller instead of invoking binaries directly. This is typically configured by your admin, but it is useful to understand what it means for you.

With a controller:

  • Workflows are registered once with the controller.
  • You trigger them by:
    • Clicking a button in a UI.
    • Sending an HTTP request to a trigger endpoint.
    • Scheduling them (for example, “run every hour”).

From a user’s point of view:

  • You no longer need to remember full binary paths.
  • You can see recent runs and basic status in one place (once the UI is wired up).

If your organisation uses a controller, your admin will usually give you:

  • A workflow identifier (for example, daily-report-workflow).
  • Instructions for triggering it (for example, via a small CLI or an internal web page).

Advanced: Traces and Diagnostics

If you are a power user and want more insight into what your workflows are doing at runtime, compiled binaries can emit trace logs.

Enabling Traces

Before running a workflow:

export N8N_TRACE_PATH=/path/to/trace.jsonl
/path/to/your/my-workflow-linux

This causes the workflow to append structured JSON lines to the specified file as it runs, including:

  • Node execution start/finish times.
  • Status (success/failure) per node.
  • Basic diagnostic messages.

Viewing Traces

You can use the trace-viewer tool (where available) to summarise traces:

trace-viewer /path/to/trace.jsonl

This produces per‑node statistics such as:

  • Number of times each node ran.
  • Average duration per node.
  • How many runs succeeded or failed.

This is especially useful when:

  • You want to optimise a workflow that runs many times per day.
  • You need to debug occasional failures without editing the workflow itself.

If you are not comfortable with these tools, you can ignore this section; workflows still run fine without traces.

Best Practices for Working With Binaries

To minimise headaches:

  • Keep versions organised

    • Name folders by environment and date (for example, workflows/prod/2025-01-15/).
    • Keep a small text README with the workflow name, version, and URL to its marketplace entry.

  • Use consistent locations

    • For frequently used binaries, add them to a directory on your PATH so you can run them by name.

  • Avoid editing binaries

    • Binaries are compiled artefacts; if you need to change behaviour, update the workflow definition and compile a new binary.

  • Work with your admin

    • For scheduled or webhook‑based workflows, coordinate with whoever manages the controller and infrastructure to ensure they are deployed correctly.

By following these practices, you can treat workflows as reliable tools in your toolbox and avoid fragile, one‑off setups.

Pricing & Subscriptions

BinaryCircuits operates on a hybrid freemium model, designed to be flexible and provide value whether you are a hobbyist or a large enterprise. Our model combines:

  • A generous Free tier.
  • Several subscription tiers for regular users.
  • The option to purchase individual, high‑value workflows a la carte.

The core principle is simple:

You pay for access and compilation. The compiled binaries you create are yours to run forever.

All prices below are in GBP (£).

Subscription Tiers at a Glance

TierMonthly PriceTypical UserHigh‑Level Benefits
Free£0Hobbyists & beginnersTry the platform with free workflows and small limits
Hobbyist£9Power users & tinkerersPersonal projects and side‑projects
Pro£29Professionals & small teamsBusiness‑critical workflows and regular usage
Business£99Teams & companiesAutomation across multiple departments
Enterprise£299+Large‑scale deploymentsCustom, high‑touch, and on‑premise options

Where appropriate, yearly plans are available at a discount (for example, Hobbyist at roughly £90/year, Pro at roughly £290/year).

What Subscriptions Actually Control

Your subscription tier affects:

  • How many workflows you can compile or download per month.
  • Which marketplace workflows you can access without extra payment (for example, all workflows up to a certain price).
  • Support level and response time.

Your subscription does not control:

  • Whether compiled binaries you already have will continue to run (they will).
  • How many times you can execute a compiled workflow.
  • How many servers or machines you can deploy a compiled binary to.

If your subscription changes or expires:

  • You keep full use of any binaries you have already compiled or downloaded.
  • You may lose access to compile or download new workflows until you re‑subscribe or purchase a la carte.

Detailed Tier Breakdown

Free Tier

  • Price: £0 / month
  • Compiler Access: Base software (TUI/CLI) is free forever.
  • Compilations: Around 5 workflow compilations per month (suitable for testing and light usage).
  • Workflow Marketplace: Access to the entire library of free workflows (over 3,000 available).
  • Support: Community support only.

Good for:

  • Evaluating the platform.
  • Running a few personal automations.
  • Trying out workflows before deciding whether to subscribe or buy a specific one.

Hobbyist Tier

  • Price: £9 / month (with discounted annual option).
  • Compiler Access: Full access for personal use.
  • Compilations/Downloads: Around 25 per month.
  • Workflow Marketplace: Access to all Free and Starter tier workflows (over 12,000 available, typically priced up to around £8).
  • Support: Email support with a target 48‑hour response time.

Good for:

  • Power users and technical hobbyists.
  • Maintaining a small collection of personal or side‑project workflows.
  • Experimenting heavily with automation without enterprise‑level costs.

Pro Tier

  • Price: £29 / month (with discounted annual option).
  • Compiler Access: Full access.
  • Compilations/Downloads: Around 100 per month.
  • Workflow Marketplace: Access to all workflows in the Free, Starter, and Professional tiers (over 19,000 available, typically priced up to around £39).
  • Support: Priority email support with a target 24‑hour response time.

Good for:

  • Freelancers and small teams.
  • Running business‑critical workflows in production.
  • Integrating BinaryCircuits‑compiled workflows into client projects or internal tools.

Business Tier

  • Price: £99 / month (with discounted annual option).
  • Compiler Access: Full access.
  • Compilations/Downloads: Effectively unlimited for typical business use.
  • Workflow Marketplace: Access to all workflows in the marketplace, regardless of price tier.
  • Support: High‑priority support with a target 12‑hour response time and team‑oriented licences.
  • Extras: Better options for multi‑user access and internal governance.

Good for:

  • Teams that rely on automation across multiple projects or departments.
  • Organisations that want predictable costs and access to the full catalogue.

Enterprise Tier

  • Price: Starting at £299 / month (custom pricing based on needs).
  • Compiler Access: Full access, including advanced features as they are developed.
  • Compilations/Downloads: Unlimited, subject to fair‑use and contract terms.
  • Workflow Marketplace: Full marketplace access plus options for custom, private workflows.
  • Features: White‑labelling, custom deployment options (including on‑premise), and dedicated infrastructure where required.
  • Support: Dedicated support channel with a formal Service Level Agreement (SLA).

Good for:

  • Large organisations with strict security, compliance, or uptime requirements.
  • Companies that want private, bespoke workflows and deployment models.

A La Carte: One‑Time Workflow Purchases

If you don’t want a subscription, or you only need a small number of specific workflows, you can purchase individual workflows directly from the marketplace.

  • Price Range: Typically from about £40 to £149 for high‑value workflows.
  • Ownership: You receive a permanent right to compile and use that specific workflow under the licence terms.
  • Usage: Once compiled, you can run the resulting binary as many times as you like, on as many machines as you like, without additional fees from BinaryCircuits.

This model is ideal if:

  • You have a very focused use case (for example, a single AI pipeline).
  • You prefer capital expenditure (one‑off purchases) over ongoing subscription costs.
  • You want to own a small number of powerful workflows outright.

Choosing the Right Tier

A few rule‑of‑thumb suggestions:

  • Just exploring → Start with Free. You can always upgrade later.
  • Serious personal use or side projects → Hobbyist is usually enough.
  • Consultants, agencies, or small teams → Pro balances cost and value well.
  • Automation across a whole company → Business typically makes sense.
  • Heavily regulated or very large organisations → Talk to us about Enterprise.

If you are unsure, it’s perfectly fine to start on a lower tier and upgrade if you hit your compilation or access limits. The platform is designed so that moving between tiers does not break your existing workflows; it only affects what you can access and how much you can compile going forward.

Licensing Explained

The BinaryCircuits licensing model is designed to be simple and fair. It’s important to understand what is licensed and what is not, especially if you plan to use workflows in production or ship them as part of your own products.

Our philosophy is: We license the tool, not the output.

What Your License Covers

Your BinaryCircuits subscription and licence key grant you access to the tools and services provided by the platform. This includes:

  1. The compiler and tooling: Your licence key (tied to your subscription tier) activates the compiler (TUI/CLI/GUI), enabling you to perform workflow compilations and downloads.
  2. Marketplace access: Your subscription tier determines which workflows you can access, browse, and download from the marketplace.
  3. Compilation/download quotas: The licence enforces the number of compilations or downloads you can perform each month, as defined by your tier (for example, 25/month for Hobbyist).

Your licence is typically machine‑bound, and activation limits are based on your subscription tier. This prevents abuse and ensures fair use of the platform’s resources, while still letting you deploy compiled binaries widely.

What is NOT Licensed

This is the most important part of our model:

The compiled workflow binaries that you create are not subject to a runtime licence from BinaryCircuits.

Once you use your subscription to compile a workflow, the resulting binary file is your property.

  • You can run it as many times as you want.
  • You can deploy it on any number of servers.
  • You do not owe BinaryCircuits any runtime fees or royalties.
  • The binary does not “call home” to enforce a licence check.

Think of it like using a word processor: you pay for the software (Microsoft Word), but the PDF documents you create are yours to distribute and use freely. In the same way, you subscribe to BinaryCircuits for the compiler and marketplace, but the binaries you produce are yours to own and operate without restriction.

This model provides the best of both worlds: access to a powerful, managed platform and true ownership and freedom for your compiled automation logic.

Using Compiled Binaries in Your Own Products

Because BinaryCircuits does not enforce runtime licensing on compiled binaries:

  • You can embed a compiled workflow binary into your own applications or services.
  • You can deploy compiled binaries to customers’ infrastructure (for example, as part of an on‑premise solution).
  • You can scale horizontally (more machines, more containers) without worrying about per‑node runtime fees.

You are still responsible for:

  • Complying with any third‑party licences associated with the workflow itself (for example, licence terms specified by the workflow author, if applicable).
  • Ensuring that your use respects any local laws, regulations, and contractual commitments.

If you are planning a large‑scale redistribution or white‑label offering, the Enterprise tier is usually the right place to start that conversation.

What Happens If You Cancel Your Subscription?

If you cancel or downgrade your subscription:

  • You keep full use of any binaries you have already compiled or downloaded.
  • You will no longer be able to:
    • Compile new workflows beyond the limits of your current (or free) tier.
    • Access premium marketplace content reserved for higher tiers.
  • You may lose access to support levels that were previously included with your subscription.

In other words, cancelling a subscription affects future access and compilation but does not retroactively “switch off” binaries you already have.

Multiple Machines and Environments

BinaryCircuits is designed to support real‑world deployment scenarios:

  • You can deploy a compiled binary across development, staging, and production environments.
  • You can run the same binary in multiple regions or clouds.
  • You can script or automate deployments using your existing tools (Ansible, Terraform, container orchestrators, etc.).

Licence enforcement happens at the tool level (compiler, marketplace access), not at the level of individual servers that run compiled binaries.

Summary – Key Licensing Principles

To recap, the key points are:

  1. You licence the BinaryCircuits tools, not the output.
  2. Compiled binaries are yours to run freely on any infrastructure you control.
  3. Subscriptions control access and compilation, not runtime execution.
  4. Cancelling a subscription does not de‑activate existing binaries.

If you have a legal or compliance team, you can share this chapter with them as a high‑level overview, and refer them to your contract or Enterprise agreement for formal terms and conditions.

Getting Support

If you encounter issues or have questions, we offer several channels for support, depending on your subscription tier and the nature of your problem.

Community Support

For all users, especially those on the Free tier, our community forum is the best place to start. Here you can:

  • Ask questions and get help from other users.
  • Share your projects and see what others are building.
  • Report bugs and suggest new features.

(Link to community forum will be added here.)

Community channels are ideal for:

  • “How do I…?” usage questions.
  • Sharing ideas or workflows with others.
  • Getting feedback on potential improvements or feature requests.

Email Support

For subscribers on the Hobbyist, Pro, and Business tiers, we offer direct email support.

  • Hobbyist: Guaranteed response within 48 hours.
  • Pro: Priority response within 24 hours.
  • Business: High-priority response within 12 hours.

Please send your support requests to support@matrixforge.io from the email address associated with your account.

When contacting email support, it helps to include:

  • The email address and subscription tier associated with your account.
  • The name (and, if possible, ID or version) of the workflow you are using.
  • A short description of what you expected to happen and what actually happened.
  • Any relevant log output, error messages, or screenshots (avoid including secrets or credentials).

Dedicated Support

Enterprise customers receive a dedicated support channel, a direct line to our engineering team, and a Service Level Agreement (SLA) tailored to their needs. Please refer to your Enterprise contract for details on how to access your dedicated support.

Typical Enterprise arrangements can include:

  • A named technical contact or account manager.
  • Scheduled check‑ins to review usage, roadmap, and upcoming changes.
  • Assistance with roll‑outs, migrations, and custom integrations.

Reporting Issues

If you believe you have found a bug in the software or a security vulnerability in a workflow, please report it to us immediately at security@matrixforge.io. We take all security reports very seriously.

When reporting a potential security issue:

  • Please do not share sensitive details publicly.
  • Include enough information for us to reproduce the issue (affected workflow, environment, and steps).
  • If possible, redact or anonymise user data.

We will acknowledge your report, investigate, and keep you updated on our progress according to the severity of the issue and your support tier.

Self‑Help Resources

In addition to direct support, you can use:

  • The User Guide (this documentation) for end‑user workflows, pricing, and licensing.
  • The Developer Guide for deeper technical insight if you are also administering or extending BinaryCircuits.
  • The cargo doc‑generated API documentation (for administrators and developers) when working directly with the Rust crates.

Whenever possible, we try to keep these documents up‑to‑date so that many common questions can be answered without waiting for a support response.

Troubleshooting & FAQ

This chapter collects common questions and issues so you can solve most problems yourself without contacting support.

If you do end up needing help, having worked through these steps will also make it easier for support to assist you quickly.

Login and Account Issues

“Failed to connect to API server”

Symptom:

  • On the login screen, you see an error like:

    Failed to connect to API server at [::1]:50051 …

What it means:

  • The backend API server is not running or not reachable from your machine.

What to do:

  • Check your internet connection.
  • If you know you should be connecting to a local deployment, ensure your BinaryCircuits admin has started the API server.
  • If the problem persists, forward the full error message to your admin or support.

“Login failed” or “No access token received”

Symptom:

  • After entering email/password and pressing Enter, you see an error message and stay on the login screen.

Possible causes:

  • Email or password typo.
  • Your account doesn’t exist yet (try registering).
  • The server had an internal error.

What to do:

  • Double‑check your email and password.
  • If you are new, use the Register mode (press Tab to switch) to create an account.
  • If the error message mentions a server issue, try again later or contact support with the exact text.

“I want to log out everywhere”

Symptom:

  • You want to ensure you’re logged out and your session is cleared on your machine.

What to do:

  • Use any in‑app logout option if present.

  • If you want to force a local logout:

    rm ~/.matrixforge/session.json

  • Next time you start the app, you’ll be asked to log in again.

Marketplace and Purchases

“The marketplace is empty”

Symptom:

  • The Browse screen shows no workflows, or you repeatedly see “Failed to load workflows”.

Possible causes:

  • Connection problems to the API.
  • Misconfigured filters (in future releases).
  • Server‑side issues.

What to do:

  • Confirm you are logged in.
  • Look at any error message at the bottom of the screen for more details.
  • If the error mentions network or server problems, contact your admin or support with the message.

“I can’t add a workflow to my cart”

Symptom:

  • Pressing a does nothing, or you see “Already in cart”.

What to do:

  • Check whether the workflow is already in your cart:
    • Press 3 to go to the Cart screen and review the items.
  • If it is already there, you do not need to add it again.

“Checkout failed”

Symptom:

  • After confirming purchase in the Cart, you see an error like “Purchase failed: …”.

Possible causes:

  • Payment provider rejected the transaction.
  • Your subscription tier does not allow purchasing this workflow.
  • Temporary server issue.

What to do:

  • Note the exact error message.
  • Verify that your subscription tier should allow the purchase (see the Pricing chapter).
  • Try again once; if it still fails, contact support with:
    • The workflow name.
    • The approximate time.
    • The full error message shown.

Workflows and Execution

“How do I know if a workflow is compilable?”

Answer:

  • In the Browse and Details screens you’ll see a Compilation section or a “Compilable ✓” indicator.
  • If a workflow is marked as not compilable, it typically means:
    • It uses nodes that the compiler does not support yet, or
    • There were validation issues.

For such workflows, you can:

  • Watch for updates from the author.
  • Request support for missing nodes via the platform’s node request system (where available).

“My compiled workflow runs but produces no output”

Possible causes:

  • The workflow is designed to perform side‑effects only (for example, send an email), not return a JSON payload.
  • The workflow expects specific input and quietly exits if conditions are not met.

What to do:

  • Re‑read the workflow description to see what it claims to do.
  • Check any provided usage examples to ensure:
    • Your input JSON matches what it expects.
    • Any required environment variables or credentials are set.

If it still seems wrong, contact the workflow author or support with:

  • The workflow name and version.
  • The exact command you ran.
  • A sample of your input JSON (with sensitive data redacted).

“The workflow is slow”

Possible causes:

  • Heavy external API calls (for example, large AI models, third‑party services).
  • Large data sets flowing through nodes.
  • Network latency in your environment.

What to do:

  • If possible, test on a machine closer to the services it calls.
  • Use traces (see “Working With Workflows” chapter) to identify which parts of the workflow are slow.
  • If a particular workflow is consistently slow for all users, raise it with the workflow author or support.

Pricing, Tiers, and Licensing

“Why can’t I access a particular workflow?”

Possible reasons:

  • Your subscription tier does not include workflows at that price level or category.
  • The workflow has been restricted to higher‑tier users or is part of a special offer.

What to do:

  • Check your current tier (visible in your account area or from your admin).
  • Review the Pricing & Subscriptions chapter to see which tiers can access which workflows.
  • Consider:
    • Upgrading your subscription, or
    • Purchasing the workflow individually if offered a la carte.

“Will my binaries stop working if I cancel my subscription?”

Answer:

  • No. Compiled binaries you already have will continue to run.
  • Cancelling or downgrading affects:
    • Your ability to compile new workflows.
    • Your access to certain marketplace content.
    • Your support level.

You retain the right to run existing binaries indefinitely, subject to any local laws or agreements you must follow.

When to Contact Support

If you have worked through the relevant sections of this guide and still have issues, it’s time to contact support. To make the process faster, include:

  • Your account email and subscription tier.
  • The workflow name and version (if applicable).
  • A clear description of:
    • What you tried to do.
    • What you expected to happen.
    • What actually happened (including any error messages).
  • The approximate time the issue occurred.

Use:

  • Community channels for general “how do I…?” questions.
  • Email support (if your tier includes it) for account, billing, or platform problems.
  • The security reporting address for anything that looks like a security vulnerability.

The more detail you provide up front, the fewer back‑and‑forth messages will be needed to resolve your issue.