---
title: "moreutils: small browser tools that do one thing"
description: "Nine free browser tools, with screenshots and the architecture behind each. Inspired by Joey Hess's moreutils."
author: "Kevin Pham"
published: "2026-10-30"
category: "Field Notes"
url: "https://deoxy.net/blog/the-joy-of-a-tool-that-does-one-thing/"
---

# moreutils: small browser tools that do one thing

I've been building small tools and putting them at [moreutils](https://moreutils.com/). I use them myself and share them with friends. They're free, with no accounts or ads.

This was inspired by [Joey Hess's moreutils](https://joeyh.name/code/moreutils/), a collection of small Unix utilities including `sponge`, `ts`, and `vidir`. Mine run in the browser. I enjoy giving an ordinary task a focused tool, then having a link I can hand someone.

Here are the nine public tools and how they're built. The screens were captured on October 29, 2026; the animations are the apps' own example walkthroughs. The diagrams group components by where they run and where state is kept.

## [Split](https://split.moreutils.com/)

Scan a restaurant receipt and let everyone claim what they ordered. Use it after a group dinner when one person covers the bill and an even split wouldn't be fair.

**Video: Split: the app’s entry screen**

A capture of Split’s public entry screen with its original illustrative homepage animation. The static poster shows the same screen under reduced motion.

<https://deoxy.net/video-clips/moreutils-split-walkthrough-cec99238ba00870a.mp4>

**Diagram: Split architecture**

Participant browsers hold the bill. Guest claims reach the host reducer over WebRTC, and the host saves state locally. Network services provide receipt scanning through a Cloudflare Worker and vision provider, plus peer introduction through Nostr relays.

_The host owns the bill. Receipt OCR and peer introductions use services; optional TURN transport is omitted._

```d2
direction: right

browsers: Participant browsers {
  host: "Host\nreducer + save"
  guests: "Guests\nclaim + view"
}

services: Network services {
  scan: "Scan API\nWorker"
  vision: Vision model
  relays: Nostr
}

browsers.guests -> browsers.host: WebRTC
services.scan -> services.vision: OCR
browsers -> services: "Receipt scans + peer setup"
```

## [When](https://when.moreutils.com/)

Share a poll with possible dates, collect availability, and put the chosen date on the calendar. For dinners, trips, or meetings that would otherwise take a long thread to arrange.

**Video: When: the app’s entry screen**

A capture of When’s public entry screen with its original illustrative homepage animation. The static poster shows the same screen under reduced motion.

<https://deoxy.net/video-clips/moreutils-when-walkthrough-26da747475fa3a23.mp4>

**Diagram: When architecture**

The browser presents the poll. In Cloudflare, a Worker reads and writes poll data in D1, a Durable Object carries live presence and change notices, and Cron initiates reminder checks.

_Answers persist in D1. The live room carries presence and change notices; Cron checks reminders._

```d2
direction: right

browser: Participant browsers {
  ui: "Poll interface\nhost + guests"
}

cloudflare: Cloudflare {
  api: "Poll API\nWorker"
  data: "Polls\nD1" {
    shape: cylinder
  }
  live: "Live room\nDurable Object"
  cron: "Reminders\nCron"
}

cloudflare.api -> cloudflare.data: save
cloudflare.api -> cloudflare.live: changed
cloudflare.cron -> cloudflare.api: check
browser -> cloudflare: HTTP + WebSocket
```

## [Groupchat](https://groupchat.moreutils.com/)

Collect names and phone numbers through one shared code, then start a group text. Add a group photo to remember who's who after an event.

**Video: Groupchat: the app’s entry screen**

A capture of Groupchat’s public entry screen with its original illustrative homepage animation. The static poster shows the same screen under reduced motion.

<https://deoxy.net/video-clips/moreutils-groupchat-walkthrough-8dda62167a974c78.mp4>

**Diagram: Groupchat architecture**

Participant browsers exchange the live roster over WebRTC. Cloudflare hosts a Worker for face detection and saved data, a Durable Object for peer setup, D1 for encrypted links, and R2 for encrypted group photos.

_The roster is peer to peer. Saved links and photos are encrypted; face detection runs in the Worker._

```d2
direction: right

browsers: Participant browsers {
  host: "Host\ngroup roster"
  guests: "Guests\njoin + contacts"
}

cloudflare: Cloudflare {
  api: "Faces + API\nWorker"
  room: "Peer setup\nDurable Object"
  links: "Links\nD1" {
    shape: cylinder
  }
  photos: "Photos\nR2" {
    shape: cylinder
  }
}

browsers.host -> browsers.guests: WebRTC
cloudflare.api -> cloudflare.room: signaling
cloudflare.api -> cloudflare.links: encrypted
cloudflare.api -> cloudflare.photos: encrypted
browsers -> cloudflare: "Setup + saved links + photo"
```

## [Livekaraoke](https://livekaraoke.moreutils.com/)

Find live-band karaoke nights around LA, or search for a song and see which bands play it. Check the set list before heading out for the night.

_Image: Livekaraoke's public entry screen shows song search and upcoming live-band karaoke nights around LA._

**Diagram: Livekaraoke architecture**

Band and venue sources enter a listings service containing a refresh Workflow, Workers AI extraction, D1 listings, and a serving Worker. Model candidates pass through refresh validation before database writes. R2 retains source snapshots; browsers and calendars receive published listings.

_Model candidates pass through validation before becoming listings. R2 retains the source evidence._

```d2
direction: right

sources: Band and venue sources

cloudflare: Listings service {
  refresh: "Refresh\nWorkflow"
  model: "Extract\nWorkers AI"
  data: "Listings\nD1" {
    shape: cylinder
  }
  web: "Pages + ICS\nWorker"
}

archive: "Source snapshots\nCloudflare R2" {
  shape: cylinder
}

readers: Browser and calendar

cloudflare.model -> cloudflare.refresh: candidates
cloudflare.refresh -> cloudflare.data: commit
cloudflare.data -> cloudflare.web: read
sources -> cloudflare: Feeds + pages
cloudflare -> archive: source copies
cloudflare -> readers: Listings + events
```

## [Parking](https://parking.moreutils.com/)

Check a curb's rules against how long you plan to stay and set a move-by reminder. For a stop where street sweeping or a time limit might send you back to the car.

_Image: Parking's public entry screen asks for a destination and length of stay, and offers a way to check an existing parking spot._

**Diagram: Parking architecture**

Offline imports prepare curb and map datasets. Within Cloudflare, a Worker reads D1 curbs and R2 map and occupancy data to compute a plan, and a Durable Object schedules a move-by alarm. The browser presents the plan and reminders.

_The Worker computes the plan. A Durable Object schedules the move-by reminder._

```d2
direction: right

imports: Offline build {
  prepare: Import datasets
}

cloudflare: Cloudflare {
  curbs: "Curbs\nD1" {
    shape: cylinder
  }
  map: "Map data\nR2"
  planner: "Plan\nWorker"
  reminder: "Alarm\nDO"
}

browser: Browser {
  ui: "Destination + stay\nmap + reminder"
}

cloudflare.curbs -> cloudflare.planner: rules
cloudflare.map -> cloudflare.planner: map data
cloudflare.planner -> cloudflare.reminder: schedule
imports -> cloudflare: Curb + map datasets
cloudflare -> browser: Plans + reminders
```

## [Send](https://send.moreutils.com/)

Send files between browsers with a link or QR code, adapted from [FilePizza](https://github.com/kern/filepizza). Use it to move a file between your phone and laptop, or hand one to someone nearby.

**Video: Send: the app’s entry screen**

A capture of Send’s public entry screen with its original illustrative homepage animation. The static poster shows the same screen under reduced motion.

<https://deoxy.net/video-clips/moreutils-send-walkthrough-5b5583868a6f4ab8.mp4>

**Diagram: Send architecture**

The sender reads local files and sends their bytes over WebRTC to a receiving browser for verification and saving. A separate connection service contains a Worker link API and a Durable Object signaling room.

_File bytes travel over WebRTC. The server handles link setup; this app has no TURN fallback._

```d2
direction: right

browsers: Participant browsers {
  sender: "Sender\nlocal files + reader"
  receiver: "Receiver\nverify + save"
}

cloudflare: Connection service {
  api: "Link API\nWorker"
  room: "Signaling room\nDurable Object"
}

browsers.sender -> browsers.receiver: "WebRTC"
cloudflare.api -> cloudflare.room: signaling
browsers -> cloudflare: Connection setup
```

## [Sign](https://sign.moreutils.com/)

Fill in and sign a PDF, or invite someone to sign it with you, then save the finished copy. For forms that need a signature without printing, scanning, or emailing drafts back and forth.

_Image: Sign's public entry screen offers a PDF chooser and shortcuts to common forms._

**Diagram: Sign architecture**

The host browser edits PDFs with PDF.js and pdf-lib and shares the document with a signer over WebRTC. Cloudflare hosts the link API and a Durable Object room for admission and connection setup.

_The signing room coordinates admission; filled PDFs travel between the browsers._

```d2
direction: right

browsers: Participant browsers {
  host: "Host\nPDF.js + pdf-lib"
  signer: "Signer\nPDF + fields"
}

cloudflare: Cloudflare {
  api: "Link API\nWorker"
  room: "Admission + setup\nDurable Object"
}

browsers.host -> browsers.signer: WebRTC
cloudflare.api -> cloudflare.room: link init
browsers -> cloudflare: Request + approve + signal
```

## [Slides](https://slides.moreutils.com/)

Present a PDF across everyone's browsers, with synchronized pages, pointers, drawing, and notes. For a small meeting or a room where people need to follow along on their own screens.

**Video: Slides: the app’s entry screen**

A capture of Slides’s public entry screen with its original illustrative homepage animation. The static poster shows the same screen under reduced motion.

<https://deoxy.net/video-clips/moreutils-slides-walkthrough-eae52fa7f3162a09.mp4>

**Diagram: Slides architecture**

The presenter orders and signs presentation state, saves decks and versions in IndexedDB, and sends PDFs and state over WebRTC to verifying viewers. Cloudflare hosts a room API and a Durable Object signaling relay.

_The presenter owns live state and local deck history; viewers verify its signed reports._

```d2
direction: right

browsers: Participant browsers {
  presenter: "Presenter\nsign + order"
  viewers: "Viewers\nverify"
  decks: "Decks\nIndexedDB" {
    shape: cylinder
  }
}

cloudflare: Cloudflare {
  api: "Room API\nWorker"
  room: "Signaling\nDurable Object"
}

browsers.presenter -> browsers.viewers: "WebRTC"
browsers.presenter -> browsers.decks: save
cloudflare.api -> cloudflare.room: create room
browsers -> cloudflare: Connection setup
```

## [Secrets](https://secrets.moreutils.com/)

Send someone a receiving link so they can encrypt a reply that only your browser can open. For a password or other private message you need to exchange through an existing chat.

**Video: Secrets: the app’s entry screen**

A capture of Secrets’s public entry screen with its original illustrative homepage animation. The static poster shows the same screen under reduced motion.

<https://deoxy.net/video-clips/moreutils-secrets-walkthrough-a04c296c384e6df7.mp4>

**Diagram: Secrets architecture**

In the default exchange, the recipient holds a non-exportable X25519 key in a local Web Worker, which decrypts replies for the reveal interface. The sender encrypts local plaintext with HPKE. A public receiving link travels out through chat or QR, and ciphertext returns.

_Default mode: receiving keys stay in the recipient’s Web Worker. The hosting Worker serves static files._

```d2
direction: right

recipient: Recipient browser {
  vault: "Private key + decrypt\nWeb Worker"
  ui: "Link + reveal UI"
}

sender: Sender browser {
  public: "Public key\nfrom link"
  secret: Secret text
  encrypt: HPKE
}

recipient.vault -> recipient.ui: "Link\nplaintext"
sender.public -> sender.encrypt: key
sender.secret -> sender.encrypt: encrypt
sender -> recipient: "Ciphertext\nchat or QR"
```
