NBP (No Bullshit Pipeline) is a Tauri 2 + Rust macOS app. It records audio, transcribes it, then runs a pipeline of steps you define. Each step gets the output of the previous one. The pipeline delivers wherever you point it.

Transcription is step one. Everything after that is yours.

I built NBP to make this part boring.

Audio in. Text out. Then deterministic steps.

No copy-paste rituals after every meeting.

How the Transcript Gets Made

Three options. Pick one.

FluidAudio is the default. A local sidecar process that runs on Apple Neural Engine. Fast. No cloud. No diarization. Your audio never moves.

Local Whisper runs via whisper-rs with Metal GPU acceleration. Models from Tiny (74 MB) to Large (2.95 GB). Download once, lives on your disk, works without network.

OpenAI Whisper API is the cloud option. Faster. Costs a few cents per hour. Useful when you’re processing long sessions and don’t want to wait.

Pick your option in settings. The rest of the pipeline doesn’t care which one ran.

What a Pipeline Step Actually Is

Each step is a connector with configuration.

The LLM connector takes a prompt and a model. It sends the previous step’s output to OpenAI, Google Gemini, or Anthropic Claude — whichever you configure — and returns what comes back. That output becomes the input for the next step.

That’s the whole processing model. Text in, text out, repeat.

Delivery connectors end a branch:

Save writes the output to disk as a Markdown file. Default location: ~/nbp-data/{uuid}/. File per step.

Webhook POSTs the output to any HTTP endpoint. Your server, your Zapier hook, your internal tool. Whatever listens receives the text.

Slack delivers to a channel or DM via bot token. Meeting ends, summary appears. No copy-paste.

Notion syncs to a database via OAuth. Structured output lands in the right place without leaving the app.

Linear creates issues. Untested by me. Plumbed in. Use at your own risk.

The Shape of a Real Pipeline

transcript → LLM (summarize) → Slack

Meeting ends. FluidAudio produces the transcript. The LLM step summarizes it — three bullet points, what happened, who decided what. Slack delivers it to #meeting-notes. Done before you’ve closed your laptop.

transcript → LLM (extract action items) → Notion

Same transcript, different pipeline. The LLM step pulls names, tasks, deadlines out of 8,000 words of meeting noise. Notion syncs the structured result to your project database.

transcript → LLM (draft follow-up email) → Save

The model drafts from the transcript. Save writes it to ~/nbp-data/{uuid}/followup.md. Open it, edit it, send it. The draft is there when you need it.

Three pipelines. One transcript. None of them interfere with each other.

Steps Run Sequentially

The pipeline is a chain.

Step one gets the transcript. Step one’s output goes to step two. Step two’s output goes to step three. And so on.

Each step has a status: Waiting, Running, Done, or Partial. The UI tracks them individually. If a step fails, you see which one. The others are unaffected.

There’s no branching. No conditional logic. No parallel execution. Steps run in order, one at a time. That’s intentional. Simple to reason about. Simple to debug.

If you want two different outcomes from the same transcript — summary to Slack, action items to Notion — you run two pipelines. Each is independent. Each tracks separately.

What You Configure

transcript → LLM → Save

Minimum viable pipeline. One LLM step with a prompt. Save to disk. That’s it.

Add steps when they’re useful. Remove them when they’re not. The pipeline doesn’t impose a minimum or maximum.

An empty pipeline — no steps after transcription — just gives you the transcript. The OGG audio, the JSON transcript, and nothing else. That’s a valid outcome.

The tool doesn’t decide what useful means. You write the prompts. You pick the models. You point the delivery connectors. The pipeline runs what you configure.

Storage

Every recording gets its own directory.

~/nbp-data/{uuid}/
├── audio.ogg          # the recording
├── transcript.json    # raw transcript output
├── summary.md         # Save step output
└── action-items.md    # second Save step output

Plain files. Open in anything. No database. No proprietary format.

The transcript is always there. The pipeline outputs accumulate alongside it. Delete what you don’t need.

The Model Doesn’t Matter

The LLM connector supports OpenAI, Google Gemini, and Anthropic Claude. Different steps can use different models.

Summarization doesn’t need the most capable model. Classification needs less. Action item extraction might need something smarter. You make the call per step.

The pipeline doesn’t assume one provider for everything. It calls what you configure. Swap a model without touching anything else.

What the Transcript Enables

Accurate text from audio is the unlock.

Everything downstream is a text processing problem. LLMs handle text. APIs handle text. Every tool in the stack knows what to do with text.

The hard part was audio to text. That’s done. FluidAudio or Whisper handles it. What comes after is yours.

---

Next: The Review Passed. Everything Was Broken..

• #nbp
• #pipelines
• #audio