It renders a video wall directly on youtube.com — up to 9 videos in a 3x3 grid or free-floating windows. Audio follows your mouse: hover a video to hear it, the rest mute. You can grab the video you're currently watching into the grid at its exact timestamp.
Free and open source (Chrome, converts to Safari): https://github.com/mikewang817/multi-youtube-viewer
It overlays a video wall directly on youtube.com — hover any thumbnail and hit + to add it, up to 9 videos in a 3x3 grid or free-floating windows. Audio follows your mouse: hover a video to hear it, everything else mutes. Esc minimizes it and everything keeps playing while you browse.
Free and open source: https://github.com/mikewang817/multi-youtube-viewer
I watch a lot of NBA games and tech interviews at the same time, and juggling tabs drove me crazy. So I built a small browser extension that renders a multiview grid directly on youtube.com — no separate site, no tab juggling.
What it does:
The fun part was discovering that YouTube actively refuses to embed itself (error 152, EMBEDDER_IDENTITY_DENIED in the player config) — that rabbit hole took longer than the actual UI.
It's on GitHub if anyone wants to poke around: https://github.com/mikewang817/multi-youtube-viewer
Happy to answer questions!
Most "productivity launchers" are GUI apps that happen to run near a terminal. Prelude is the opposite: it's a terminal-native launcher — same fzf-driven panel whether you summon it with Ctrl+R at a zsh prompt or a global hotkey from anywhere on the machine.
What it searches: shell history, files/folders, running processes and open ports, apps, clipboard history (including images), saved quicklinks, and — the part I actually built it for — coding-agent sessions and skills. If you've got Claude Code, Codex, or a handful of other agent CLIs installed, it lists their conversations and lets you resume with the agent's own syntax.
It never runs a command for you — everything lands on the clipboard so you read it before you paste it. Objects (files, folders, apps, URLs) just open, no shell involved.
Rust, Apache-2.0, macOS only for now: https://github.com/mikewang817/Prelude
I built Prelude, A launcher for shell commands and the AI agents already running on your machine. Faster than Spotlight, more powerful than Spotlight, and it even runs entirely in the terminal — no extra app to install.
Recently I shared TFormula rendering LaTeX from terminal programs
directly inside Ghostty. Formula rendering turned out to be only half of the
workflow I wanted.
I learn new technical material by reading until I reach the first thing I cannot
explain, then asking a very specific question and adding the answer back to my
notes. I now do that with two Ghostty panes:
```bash
# Left pane: read the evolving document
tformula maxwell-equations.md
# Right pane: ask questions and work on the document
tformula codex
```
Codex is just the command in this example. The right pane can use Claude Code,
Gemini CLI, OpenCode, Aider, or another terminal tool. TFormula does not depend
on any particular agent.
The left pane is TFormula’s new full-screen document reader. It parses the local
Markdown and lays it out again for the current pane width, including headings,
lists, tables, code, links, scientific formulas, and local images. It also has a
table of contents, search, heading navigation, and a source-view toggle.
The part that made this setup click for me is live reload. The reader watches
the document and its local images. If I edit the note—or ask the agent in the
right pane to expand a derivation, add an example, or clarify a section—the left
pane refreshes after the file is saved. It keeps my reading position and image
zoom, so I do not have to close the reader or find my place again.
My loop is now:
The conversation helps me explore, but the Markdown file becomes the durable
result. That distinction matters to me: TFormula makes the material easier to
work with, but it does not make an agent’s answer correct.
You can also wrap the entire shell instead of individual commands:
```bash
tformula --shell
```
Install:
```bash
npm install -g tformula --allow-scripts=node-pty --allow-scripts=sharp
```
Ghostty remains the primary development and test target. Kitty and WezTerm are
also supported through the Kitty graphics protocol.
GitHub: https://github.com/mikewang817/TFormula
npm: https://www.npmjs.com/package/tformula
Does anyone else use Ghostty panes this way for learning or research? I’d be
interested in what would make the handoff between the document pane and the
conversation pane feel even more natural.
This is not another terminal with built-in AI features. It is a wrapper for the CLI agents you already run inside Ghostty.
TFormula turns output such as:
\[
\nabla \cdot \mathbf{E} = \frac{\rho}{\varepsilon_0}
\]
into a properly rendered formula directly inside the terminal.
Quick install
npm install -g tformula --allow-scripts=node-pty
Under the hood, it maintains a headless xterm mirror, detects TeX on the visible screen, renders it locally with MathJax, and sends the result to Ghostty using the Kitty graphics protocol.
A surprising amount of work went into Ghostty-specific terminal behavior:
- Formula placements survive scrollback
- Resizing keeps the old image until the new one is ready
- Soft-wrapped formulas are reconstructed and sliced across rows
- The original TeX remains underneath and can still be copied
- Large responses are checkpointed so formulas are rendered before scrolling away
- Terminal clears and alternate-screen transitions are tracked
Ghostty is the primary development and test target.
GitHub: https://github.com/mikewang817/TFormula
npm: https://www.npmjs.com/package/tformula
I’d love to know how it behaves with your font, scale, and Ghostty configuration.
