bunchapp.co

Bunch.app is a macOS automation tool that uses a folder of plain text files, each containing a list of apps and commands, and presents them as a menu for one-click or keystroke-triggered "context switches." Compared with AppleScript, Bunch trades a full scripting language for a simpler, line-by-line format aimed at launching apps, changing system settings, and running scripts. It suits people who want to switch work environments quickly without writing complex scripts; AppleScript remains the better fit when you need deep, programmatic control over individual apps.

The core difference: a task list versus a scripting language

AppleScript is a general-purpose automation language with variables, handlers, conditionals, and app-specific dictionaries. Bunch is not a language in that sense. A Bunch is just a plain text file, and each line tells Bunch to perform a task, such as launching an app or changing a system setting. The site describes it as "like AppleScript but way easier."

That distinction shapes everything else:

What a Bunch file looks like

The site's example shows how terse the format is. A line can combine an app with parameters and a system state:

Audio Hijack (audio input Scarlett Solo) (do not disturb)

Each line is a task. The Bunch Folder holds all your Bunches — for example Comms.bunch, Code.bunch, and Documentation.bunch — and they become a menu ready to automate context switches. There is no need to declare variables or look up an app's scripting dictionary to get started.

Where Bunch fits better than AppleScript

Bunch is built around "contexts" — different modes of work and play that you switch between with a couple of keystrokes. The site's examples show the pattern:

• Screencast prep: a Bunch hides the Dock, changes the wallpaper, hides Desktop icons, hides all open windows, and loads your screen recording app. When it closes, it can quit apps, restore the wallpaper, unhide the Dock, and show Desktop icons again.
• Podcasting: open recording software, start a show-notes document, set audio inputs and outputs, and pause backups to save bandwidth — then put everything back when done.
• Coding project switches: close all Finder windows, open the project folder, open iTerm to the project directory and run git pull, open the project in your editor or IDE, and even start a time-tracker timer.
• Scheduled silence: a scheduled Bunch closes Twitter and other social apps during set times, and toggling the Bunch launches them again.

These are exactly the tasks where writing AppleScript would mean assembling many separate commands and app-specific syntax. In Bunch, each becomes a line or two in a text file.

Where AppleScript still wins

Bunch's simplicity is also its limit. Because a Bunch is a list of tasks rather than a programming language, anything requiring branching logic, loops, or fine-grained control over an app's internal objects is better handled in AppleScript — or in a script that Bunch runs. Bunch does support running scripts as one of its task types, so the two can coexist: use Bunch as the menu and context manager, and call AppleScript (or shell scripts) for the steps that need real logic.

How to decide

Choose Bunch if your automation is mostly "set up my environment": launching a set of apps, opening files and websites, changing system settings, and switching between named contexts from a menu. Choose AppleScript if you need conditional logic, app-specific object manipulation, or automation embedded inside another app's workflow. If you need both, start with Bunch for the context switch and delegate complex steps to scripts it runs.

Bunch is described on its site as free, with no special discounts offered to visitors.

A Bunch is a plain text file in which each line tells Bunch to perform one task—launch an app, change a system setting, load a file, open a website, or run a script. You save these files in the Bunch Folder, and Bunch turns each one into a menu item you can trigger with a couple of keystrokes. The syntax is intentionally simple, closer to a readable checklist than to a programming language, so the main prerequisite is knowing which apps and settings you want in a given context.

The basic structure

Each line is one instruction. Bunch reads the file top to bottom and acts on each line. The site's own example is a single line:

Audio Hijack (audio input Scarlett Solo) (do not disturb)

That line launches Audio Hijack, sets its audio input to Scarlett Solo, and turns on Do Not Disturb. Parenthetical modifiers attach to the item before them, which is how one line can carry more than one action.

A more typical working Bunch combines several lines:

Safari
Notes
(do not disturb)

Here Bunch opens Safari, opens Notes, and enables Do Not Disturb—three lines, three tasks, no scripting syntax to learn.

What a line can do

According to the site, a line can tell Bunch to:

• Launch apps
• Load files
• Open websites
• Change settings
• Run scripts

The same page describes the overall tool as able to "launch applications, perform system tasks, run scripts, and automate everything," and frames the syntax as "like AppleScript but way easier." That comparison is the useful mental model: you get app launching and system changes without writing AppleScript, but you are still describing a sequence of actions rather than writing logic.

From file to menu

The Bunch Folder holds all your Bunches. The site's example folder contains:

Comms.bunch
Code.bunch
Documentation.bunch

Each file becomes an entry in a menu, so a "context switch" is just picking a different Bunch. That is the core mechanism: the text file is the definition, the folder is the collection, and the menu is the trigger. You write the file once and reuse it whenever you enter that mode of work.

Practical examples of what one file can hold

The site gives several concrete Bunches that show how far a single text file can go:

The screencast and podcast examples are worth noting because they include a closing behavior: a Bunch can undo its own changes when you switch away, which is what makes it a "context" rather than a one-shot launcher.

What to check before you start

• You are on macOS. Bunch is described as a macOS automation tool; nothing on the page indicates other platforms.
• You are comfortable editing plain text. There is no mention of a graphical Bunch editor—the files themselves are the interface.
• You know the exact names of your apps and settings. Lines reference apps and system settings directly, so a typo in an app name is the most likely first failure.
• You accept that it is free. The page states plainly that "Bunch is free," so there is no purchase step before you try a first file.

If you can write a three-line list of what you open every morning, you can write a Bunch. Start with apps only, confirm the menu entry appears and launches them, then add parenthetical settings and closing behavior once the basic file works.

Bunch.app is a macOS automation tool that turns plain text files into one-click "context switches." Each Bunch file lists apps to launch and commands to run, and Bunch presents every file in your Bunch Folder as a menu item. It fits you if you repeatedly set up the same working environment—apps, files, websites, system settings—and want to switch between those setups with a couple of keystrokes instead of doing it by hand.

How a Bunch Works

A Bunch is just a plain text file. Each line tells Bunch to perform one task, such as launching an app or changing a system setting. The site's example line looks like this:

Audio Hijack (audio input Scarlett Solo) (do not disturb)

That single line launches Audio Hijack, points its audio input at the Scarlett Solo interface, and enables Do Not Disturb. The site describes the syntax as intuitive and "like AppleScript but way easier."

All Bunches live in a folder called the Bunch Folder. The site's example shows files like Comms.bunch, Code.bunch, and Documentation.bunch. Bunch reads that folder and turns each file into a menu entry, so triggering a context switch is a matter of picking it from the menu.

What Tasks Can a Bunch Perform?

According to the site, a Bunch can:

• Launch apps
• Load files
• Open websites
• Change settings
• Run scripts
• Automate "everything" else you can express as a line in a text file

Because it is plain text, you can edit a Bunch in any text editor, keep it in version control, or copy it between machines.

Example Use Cases

The site lists several concrete scenarios that show the range of the tool:

The pattern across all of these is the same: a Bunch sets up a mode of work, and closing or toggling it can reverse the changes.

Is It Right for You?

Bunch is a good fit if you:

• Work on a Mac and switch between distinct modes (coding, recording, writing, focused work)
• Are comfortable editing plain text files
• Want repeatable environment setup without writing AppleScript or a full automation script

It is a weaker fit if you prefer a graphical rule builder, need automation on Windows or Linux, or only occasionally change your setup—the overhead of writing Bunches pays off with repetition.

The site states that Bunch is free. No pricing tiers, paid plans, or login requirements are mentioned in the available material, so treat those details as unconfirmed and check the site directly if they matter to your decision.

Getting Started

1. Create a plain text file with a .bunch extension in your Bunch Folder.
2. Add one task per line—an app name, a file path, a URL, or a setting in parentheses.
3. Open the Bunch menu and select the file to run it.
4. Refine the file as you learn the syntax; the site's example Bunches (screencast, podcast, coding, and others) are the fastest reference for line formats.

The main thing to verify as you go is that each line produces the expected result—launch the Bunch and check that apps open, settings change, and closing it restores your previous state where the Bunch is designed to do so.

Bunch.app automates macOS "context switches" — the setup and teardown work around a mode of work or play. You write a plain text file (a "Bunch") where each line is an app to launch or a system task to perform, and Bunch turns the files in your Bunch Folder into a menu you trigger with a couple of keystrokes. It fits best when your repetitive work is "open these apps, load these files, change these settings, then undo it all later" — not when you need complex conditional logic.

The core mechanism

A Bunch is just a plain text file. Each line tells Bunch to do one thing, such as launching an app or changing a system setting. The site's own example line is:

Audio Hijack (audio input Scarlett Solo) (do not disturb)

That single line launches Audio Hijack, points its audio input at the Scarlett Solo, and turns on Do Not Disturb. The site describes the syntax as "like AppleScript but way easier," and says the Bunch Folder holds all your Bunches, which become a menu for triggering context switches. The actions the site lists are: launch apps, load files, open websites, change settings, and run scripts.

Concrete scenarios the site documents

Preparing to record a screencast

A Bunch hides the Dock, changes your wallpaper, hides Desktop icons, hides all open windows, and loads your screen recording app. When it closes, it can quit apps, restore your wallpaper, unhide the Dock, and show your Desktop icons again. This is the clearest illustration of Bunch's two-way design: setup on launch, cleanup on close.

Getting ready to podcast

A Bunch opens your recording software, starts a new show notes document, and sets your audio inputs and outputs. It can also pause your backups to save bandwidth, and put everything back in place when you're done.

Switching coding projects

A Bunch closes all your Finder windows, opens your project folder, opens iTerm to your project directory and runs a git pull, and opens your project in your text editor or IDE. The site notes it can even integrate with your time tracker to start project timers.

Silencing social media on a schedule

A scheduled Bunch closes Twitter and other social apps during set times. You launch them again when you're ready, just by toggling the Bunch.

Web development

A Bunch opens a project in your editor, starts a local web server, and creates a single-site browser to monitor changes while you work.

How to decide whether it fits your task

Getting started

1. Create a plain text file for one context — for example Comms.bunch, Code.bunch, or Documentation.bunch, the names the site uses.
2. Put one action per line: an app name, a file, a website, a setting, or a script.
3. Keep the file in your Bunch Folder so it appears in the menu.
4. Trigger it from the menu, and close it to run the teardown actions you defined.

The site states Bunch is free, so there's no purchase decision to weigh before trying it. The main thing to check is whether your repetitive setup work is a fixed list of actions — if so, it maps directly onto a Bunch file.

Yes. Bunch.app is free, according to its own welcome page, which notes there are no special discounts or prizes because the tool costs nothing. You get started by creating a Bunch Folder, adding a plain text file with one app or command per line, and then triggering that file from Bunch's menu. The page does not describe any paid tier, account requirement, or download steps beyond "Learn more," so treat the free claim as the vendor's statement and check the site for the current download and any system requirements before installing.

What Bunch actually is

Bunch is a macOS automation tool. It watches a folder of plain text files — the Bunch Folder — and turns each file into a menu item. Each line in a file tells Bunch to do one thing: launch an app, load a file, open a website, or change a system setting. The page describes it as "like AppleScript but way easier," and the syntax is meant to be readable at a glance.

The page's own example line is:

Audio Hijack (audio input Scarlett Solo) (do not disturb)

That single line launches Audio Hijack, sets its audio input, and turns on Do Not Disturb. Parenthetical modifiers attach to the app or setting they follow.

Getting started, step by step

1. Install Bunch and locate its Bunch Folder. The page says the Bunch Folder "contains all your Bunches," and that files in it "become a menu." The exact location is not given on this page, so confirm it in the app or documentation after installing.
2. Create a plain text file inside that folder. Name it for the context you want, such as Comms.bunch or Code.bunch — the page shows both naming styles in its examples.
3. Add one task per line. Start with a single app launch to verify the setup works, then add settings, files, or websites on their own lines.
4. Trigger it from the menu. Each file in the folder appears as a menu item; selecting it runs the lines in order.
5. Verify and iterate. If a line does nothing, check that the app name matches exactly and that any parenthetical modifiers are valid for that app. Add lines one at a time so you can tell which one fails.

What you can automate

The page groups capabilities into: launch apps, load files, open websites, change settings, and "automate everything" via scripts and system tasks. Its worked examples show the range:

The pattern across all of these is context switching: build a "context" for a mode of work and flip between contexts with a couple of keystrokes.

Practical notes before you commit

• Plain text is the whole format. There is no proprietary project file, so your Bunches are portable and editable in any text editor.
• Reversibility matters. Several examples depend on Bunch undoing changes when a Bunch closes. Test that behavior on your own setup before relying on it for something like restoring your wallpaper.
• Scheduling exists but the page only mentions it in the social-media example; check the documentation for how scheduled Bunches are configured.
• Cost: the page states Bunch is free. It does not mention pricing tiers, trials, or payment, and it also does not state licensing terms, so verify those on the site if they matter to you.

For more worked examples, the page points to its examples section ("See more examples"), which is the fastest way to find a starting template close to your own workflow.