Table of Contents

Your GitHub stars list probably has a bunch of “use this later” repos you’ve never actually opened. These aren’t those. Each one solves a very specific pain point, and most of them are things you’ll reach for within three days of installing them.

TL;DR

10 practical open-source tools you likely don’t have yet: code visualization, local CI execution, terminal UI generation, API testing, Git workflow enhancement, and more. Each has a clear use case and isn’t trying to be a general-purpose platform.

1. Carbon — Turn Code Snippets into Designer-Quality Images

GitHub: carbon-app/carbon

Posting code screenshots on Twitter or tech blogs with a raw screenshot looks rough. Carbon lets you choose a theme, font, and background color and export a polished PNG/SVG.

Good for: tech blog posts, presentation slides, README example images. Not for: code that needs to be copy-pasted — images can’t be copied.

2. Excalidraw — Whiteboard-Style Architecture Diagrams

GitHub: excalidraw/excalidraw

Lucidchart and Draw.io diagrams look too formal. Sometimes you need a “quick sketch” feel. Excalidraw produces deliberately hand-drawn style diagrams, is fully open-source, self-hostable, and supports real-time collaboration and SVG export.

There’s a VS Code extension that opens .excalidraw files directly in the editor.

3. nektos/act — Run GitHub Actions Locally

GitHub: nektos/act

Pushing to test CI workflow is one of the biggest time wasters in development. act lets you run GitHub Actions workflows locally with Docker, making iteration ten times faster.

# Install (macOS)
brew install act

# Run all workflows for push events
act push

# Run a specific job
act -j build

Limitation: some GitHub-specific actions (like actions/checkout) require extra configuration to work correctly locally.

4. Hoppscotch — Open-Source Postman Alternative, Self-Hostable

GitHub: hoppscotch/hoppscotch

Postman’s free tier is increasingly restricted, and it stores your API collections in their cloud. Hoppscotch is fully open-source, supports REST, GraphQL, and WebSocket testing, and can be self-hosted so your data stays with you.

5. Bun Shell ($) — Shell Scripts in JavaScript

GitHub: oven-sh/bun

child_process.exec is ugly, shelljs is old, Bun’s built-in $ lets you write shell syntax directly in JavaScript/TypeScript:

import { $ } from "bun";

const result = await $`ls -la`.text();
const files = await $`find . -name "*.ts"`.lines();

Cross-platform (works on Windows), fully typed, and the modern alternative for build scripts in Node.js projects.

6. Ink — Build Terminal UIs with React

GitHub: vadimdemedes/ink

You don’t need to learn ncurses to build interactive CLIs. Ink lets you write terminal interfaces as React components:

import React from 'react';
import { render, Text, Box } from 'ink';

const App = () => (
  <Box flexDirection="column">
    <Text color="green">Build complete!</Text>
    <Text dimColor>3 files processed</Text>
  </Box>
);

render(<App />);

Gatsby CLI and Parcel’s CLI are both built with Ink.

7. Slidev — Presentations for Engineers, Written in Markdown

GitHub: slidevjs/slidev

If you hate PowerPoint but need to give technical talks, Slidev lets you write slides in Markdown with Vue components, syntax-highlighted code blocks, interactive demos, and PDF/web export.

For engineers, putting presentation slides in Git for version control is itself a compelling feature.

8. Zod — Runtime Type Validation for TypeScript

GitHub: colinhacks/zod

TypeScript types disappear at runtime. When you receive data from an API, you can’t be certain it matches your expected type. Zod lets you define a schema and validate at runtime:

import { z } from "zod";

const User = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
});

const user = User.parse(apiResponse); // throws with clear error if invalid

Works especially well with tRPC — share the same schema between front-end and back-end.

9. Playwright — Modern E2E Testing

GitHub: microsoft/playwright

Selenium’s API design dates to 2004. Playwright, released by Microsoft in 2020, is the modern alternative: supports Chromium, Firefox, and WebKit, has auto-waiting (no manual sleep calls), and includes codegen to record interactions and generate test code.

npx playwright codegen https://your-app.com

10. Mermaid — Diagrams Directly in Markdown

GitHub: mermaid-js/mermaid

GitHub, Notion, and GitLab all support Mermaid natively. Write text in Markdown, get rendered flowcharts, sequence diagrams, and Gantt charts. No diagramming tool needed:

graph LR
    A[User Request] --> B[API Gateway]
    B --> C[Service A]
    B --> D[Service B]

Architecture diagrams living in the same repo as code and going through code review — that’s what documentation should look like.

Summary

What these 10 tools have in common: they each solve one specific problem instead of trying to be an “everything platform.” That focus is exactly what makes them easy to evaluate, easy to adopt, and actually useful in practice.

References

Ask this article

Answers come from this article only. Click any prompt below or open the chat at the bottom right.

🇺🇸 English

Your GitHub stars list is probably a graveyard — dozens of repos you bookmarked with the best intentions and never opened once. These ten aren't like that. Each one fixes a very specific, very real annoyance, and most of them you'll actually reach for within about three days of installing them. So let's run through them.

First up: Carbon. You know how posting a raw code screenshot to Twitter or your blog always looks kind of... cheap? Carbon fixes that. You paste in your snippet, pick a theme, a font, a background color, and it spits out a clean, polished image — PNG or SVG. Perfect for blog posts, slides, README examples. The one catch, and it's obvious: it's an image, so nobody can copy-paste the code out of it. Use it for looks, not for sharing something people need to run.

Number two: Excalidraw. Tools like Lucidchart and Draw.io make everything look corporate and stiff. Sometimes you just want that quick, hand-sketched whiteboard feel — like you scribbled it during a standup. That's Excalidraw's whole personality. It's fully open source, you can self-host it, it does real-time collaboration, and it exports to SVG. There's even a VS Code extension so you can open and edit diagram files right inside your editor.

Third, and this one's a genuine time-saver: nektos/act. Be honest — how many times have you pushed a commit just to see if your CI workflow works, watched it fail, tweaked one line, and pushed again? That push-wait-fail loop is one of the biggest silent time-wasters in development. Act runs your GitHub Actions workflows locally using Docker. Install it, and you can run all your push-event workflows or target one specific job — iteration gets maybe ten times faster. The limitation: some GitHub-native actions, like the checkout action, need a bit of extra config to behave properly on your machine.

Fourth: Hoppscotch. Postman's free tier keeps getting more restrictive, and it parks all your API collections up in their cloud. Hoppscotch is the open-source answer — it handles REST, GraphQL, and WebSocket testing, and you can self-host the whole thing, so your data stays yours. Simple as that.

Number five is Bun Shell. If you've ever tried to run shell commands from JavaScript, you know the options are ugly — the built-in child process stuff is clunky, and the older libraries feel dated. Bun has a shell built right in: you import a little dollar-sign helper, and then you write actual shell syntax directly inside your JavaScript or TypeScript. Want the output as text? There's a method for that. Want it split into lines? There's one for that too. It's cross-platform — yes, including Windows — it's fully typed, and it's honestly the modern way to write build scripts in a Node project.

Sixth: Ink. Here's a fun one. If you want to build a slick, interactive command-line tool, the old path meant learning ncurses, which is nobody's idea of a good afternoon. Ink lets you build your terminal interface using React components instead. You lay out boxes and colored text the same way you'd build a web UI — green "build complete" message, a dimmed line underneath saying how many files got processed. And this isn't a toy: the Gatsby CLI and Parcel's CLI are both built on Ink.

Seven: Slidev. If you hate PowerPoint but you still have to give technical talks, this is your tool. You write your slides in Markdown, drop in Vue components, get real syntax-highlighted code blocks and even interactive demos, and export to PDF or the web. And here's the part that clicks for engineers — your slides live in Git. Version-controlled presentations. That alone sells it for a lot of people.

Number eight: Zod. This solves a subtle but nasty problem. TypeScript's types vanish at runtime — they're a compile-time promise, nothing more. So when an API hands you data, TypeScript will happily believe it matches your type even when it doesn't. Zod lets you define a schema — say, a user needs a numeric ID, a name that's a string, and a properly-formatted email — and then validate the incoming data against it at runtime. If it's wrong, you get a clear error instead of a mysterious crash three functions later. It pairs beautifully with tRPC, where you share the exact same schema between your frontend and backend.

Ninth: Playwright. Selenium's API design basically dates back to 2004, and it feels like it. Playwright, from Microsoft, is the modern take on end-to-end testing. It drives Chromium, Firefox, and WebKit, and its killer feature is auto-waiting — no more sprinkling manual sleep calls everywhere hoping the page loaded. It also ships with a codegen mode: you literally click through your app, and it records your actions and writes the test code for you.

And number ten: Mermaid. GitHub, Notion, and GitLab all support this natively. You write plain text in your Markdown — nodes and arrows — and it renders into real flowcharts, sequence diagrams, Gantt charts, whatever you need. No separate diagramming app. Picture a simple flow: a user request goes into an API gateway, and that gateway fans out to service A and service B. You describe that in a few lines of text, and Mermaid draws it. The magic is that your architecture diagrams now live in the same repo as your code and go through code review right alongside it. That's what documentation is supposed to look like.

So what ties all ten together? Three things worth holding onto. First: every one of these does exactly one thing instead of trying to be an everything-platform — and that focus is precisely why they're easy to evaluate and easy to adopt. Second: the best of them kill a specific daily pain — the push-and-pray CI loop, the ugly code screenshot, the runtime data you can't trust. And third: for engineers, the tools that win keep your work in the places you already live — in Git, in Markdown, in your editor. Pick one, install it, and see if it earns its place by Friday.

🇹🇼 中文

打開 GitHub 動態，你會發現畫面幾乎被 AI 佔滿——AI agent 在審查另一個 AI agent 的 pull request，星星最多的 repo，其實只是一堆教你怎麼跟機器人講話的 markdown 檔。但在這層「AI 廢水」底下，還是有一群真人，在做著瘋狂、漂亮、而且深度沒必要的軟體。

今天要聊的，是 The Code Report 五月底那一集裡挑出來的幾個專案。它們的共通點不是實用，而是那種明知代價很高、還是硬要做的偏執。

先講第一個，叫 Ratty。它是一個用 Rust 寫、靈感來自 TempleOS 的終端機模擬器。它跟一般終端機最大的差別是——它不只是渲染文字，而是直接用 Bevy 遊戲引擎，渲染一整個 GPU 加速的 3D 場景。游標本身，是一隻旋轉的 3D 老鼠。你按下 Ctrl、Alt 加 Enter，可以把整個終端機在 3D 空間裡傾斜，像在玩 PS2 遊戲一樣飛過去，甚至可以把自己用 Blender 做的爛模型丟進來。唯一的代價是它會吃掉 300MB 的 RAM。作者自己也很清楚這有多離譜，他的原話是：「一切都是有代價的，尤其是那隻旋轉的老鼠游標。」

第二個，Terminal Phone。想像你人在終端機裡，Vim 開著、tmux 疊了三層 pane，這時候要接電話——你不用解鎖手機，直接從 bash 裡打。這是一個開源的按鍵通話語音跟文字 app，整個以 shell script 的形式，完全跑在 Tor 網路之上。運作方式很純粹：沒有伺服器、沒有帳號、沒有電話號碼，你的身分就是一個 .onion 位址。訊息從你的 bash 出發，經過 Tor，抵達對方的終端機，全程端對端加密，而且因為身分本身就是暫時的，一切都是短暫的。協定還是作者從零自幹的。這大概就是 1995 年那些 cypherpunk 承諾我們、卻等了三十年才有一個瘋子真的做出來的東西。

第三個沒有名字，但概念來自一部電影。1988 年，網際網路都還沒普及，John Carpenter 拍了一部片：主角戴上一副墨鏡，眼前每一塊看板、每一則廣告，都被揭露成外星人的心智控制宣傳，寫著「服從、消費、結婚、生小孩」。開發者 David Lawrence 意識到，這其實是實作一個擋廣告器，在美學上最正確的方式。他 2015 年就有這點子，放了整整十年，最近才終於做出來，是 uBlock Origin Light 的一個 fork。它不只是把廣告擋掉，而是把整個上網體驗，變成一部 80 年代的科幻恐怖片。

前面這些都出自地下室駭客，但第四個不一樣——CUDA Oxide，是市值五兆美元的 Nvidia，上週悄悄丟到 GitHub 上的，而且它解決的是一個很實際的問題。你要寫 CUDA kernel，也就是跑在 GPU 上的程式碼，得小心翼翼地雕 C++，然後祈禱 compiler 不要 segfault，因為只要一個 pointer 寫錯，就能把你價值四萬美金的 GPU 叢集變成一塊廢鐵。CUDA Oxide 想解決的就是這件事——讓你用純 Rust 寫 GPU kernel。你只要在函式上標註 kernel 這個關鍵字，就有了能真正跑在 GPU 上的 Rust 程式碼，而且它會直接編譯成 PTX，中間完全沒有 FFI、沒有任何 C++ 夾在裡面。

最後一個最好玩，叫 Wario Synth。每個很酷的專案都該有自己的主題曲，這個就是幹這個的：你貼進一首歌，它把整首歌吐回來，變成 Game Boy 的 chiptune。它底層用的是 Web Audio API，靠兩個 pulse wave、一個 wave channel 跟一個 noise channel，把整首歌重新合成成聽起來像從 1989 年 Game Boy 裡跑出來的聲音，而且這一切都直接在瀏覽器裡完成。

好，做個收尾。這五個專案，沒有一個是為了生產力而做的。

第一，它們的價值恰恰在於「沒必要」——一隻旋轉老鼠游標、一支跑在 Tor 上的電話、一個把網頁變成恐怖片的擋廣告器，全都是明知代價很高、還是硬做出來的。

第二，就連 Nvidia 這種五兆美元的巨頭，也在做同一件事——用 Rust 直接編到 PTX，把工程的偏執，變成官方工具。

第三，也是最重要的：在滿是 AI agent 互相 review 的 GitHub 動態底下，還是有人願意花力氣，做這些深度沒必要的東西。而這件事本身，就是對軟體最高等級的讚美。

Tags

#open-source#developer-tools#productivity#cli#devtools

Related Articles