Developer Tools

tldr63.3k★

tldr replaces man pages with something you'll actually read. Type `tldr tar` and you get the handful of commands people actually use, with real examples, instead of forty screens of flags. It's community-maintained, the content is CC-licensed, and every official client is open source and free. There's nothing to host. Install a client with `npm i -g tldr`, `pipx install tldr`, or `brew install tlrc`, and you're done. There's even a browser version if you don't want to install anything, and it works offline once the pages are cached. Solo or team, it's free for everyone, so the only real question is whether it earns a spot in your muscle memory. For common tools it will. The catch is coverage: it's crowd-sourced, so popular commands are excellent and obscure ones are thin or missing. When tldr comes up short you're back to man or the tool's own docs, so keep both.

chromium24.4k★

This is the open source browser engine that powers Google Chrome, Microsoft Edge, Brave, Opera, and most other browsers you use daily. If you're building a browser, an embedded web view, or anything that needs to render web pages, Chromium is the engine, on the GitHub mirror, BSD-3 licensed. To be clear: this is not a tool you install from npm. This is one of the largest open source projects in existence, millions of lines of C++. The GitHub repo is a mirror of Google's internal repository. Fully free and open source. Google funds most development. You can build Chromium from source and ship your own browser. The catch: unless you're building a browser or doing engine-level development, you don't interact with this repo directly. Most developers use Chromium through Electron, Puppeteer, or Playwright. Building from source takes hours on a powerful machine and requires specific toolchains. The star velocity reflects interest, not usability. This is infrastructure that 3 billion people use daily but almost no one builds from source.

systemd16.6k★

systemd is the init system and service manager that runs underneath most Linux distributions today. It boots your machine, manages services, collects logs through journald, and handles networking through networkd. GPL and LGPL, completely free. You probably don't pick systemd; your distribution picks it for you, and that's most of the story. Beyond 'systemctl start' and 'systemctl status', the project covers a wide surface: timer units instead of cron, unit-based isolation, socket activation, resource control through cgroups, and more. Writing a unit file is usually the cleanest way to run a daemon on a modern Linux box. The documentation is reasonable; the man pages, less so. For solo developers and small teams running anything on Linux, systemd is the default. You learn enough of it to write unit files and tail journald, and that's usually plenty. Larger teams running fleets go deeper into cgroup resource limits and socket activation. There is no paid systemd; this is infrastructure-class software. The catch: systemd is famously polarizing. Critics argue it consolidates too much into one project and breaks the Unix tradition of small composable tools. Practically: it's the default on Debian, Ubuntu, Fedora, RHEL, Arch, and most others, so opting out is a project, not a setting. If you want a different init (runit, OpenRC), pick a distro that ships it; you're not switching mid-stream.

SponsorBlock13.5k★

SponsorBlock automatically skips sponsor segments, intros, outros, and other non-content sections in YouTube videos. It's a browser extension powered by a crowdsourced database: users mark sponsor segments, and everyone else's player skips them automatically. GPL v3. Covers more than just sponsors: intros, outros, "subscribe" reminders, non-music sections of music videos, filler, and previews. The community database has hundreds of millions of submitted segments. Works on YouTube in Chrome, Firefox, and Safari, plus third-party integrations in apps like NewPipe and Invidious. Fully free. No paid tier. Community-driven and donation-supported. Install the extension, watch a video, sponsor segments skip automatically. That's it. You can also submit segments yourself when they're missing. The catch: it depends on the community submitting segments. Popular videos get covered quickly. Obscure videos might not have segments marked yet. YouTube could also break the extension with player changes (it's happened before and been fixed quickly). And some creators argue this hurts their sponsorship revenue. Fair point, and you should decide where you stand on that. The tool works. Whether you should use it is a personal call.

whatcable8.1k★

whatcable answers a question macOS hides: what can this USB-C cable actually do? Plug a charger or peripheral into a Mac, and the menu bar tells you the cable's real specs (USB 2.0 vs 5/10/20/40/80 Gbps), its power rating (3A or 5A up to 60W/100W/240W), and why charging might be slower than expected. MIT licensed, free. The data already exists in macOS via IOKit. whatcable surfaces it. No private APIs, no kernel extensions, no daemons. Install via Homebrew (`brew install --cask whatcable`) or grab the signed and notarized .app from GitHub Releases. Apple Silicon only, macOS 14 or later. The "why is my Mac charging slowly" diagnostic is the killer feature. It tells you whether the cable, the charger, or the Mac itself is the bottleneck. This is a niche utility. If you have a drawer of identical-looking USB-C cables and one of them is silently a USB 2.0 charge-only cable, you have already needed this. Free, no paid tier, single-developer maintenance. The catch: Apple Silicon only. Intel Macs use older Thunderbolt controllers that do not expose the PD state and cable e-marker data the app reads.

trio7.3k★

Trio is a Python library for async concurrency built on one big idea: structured concurrency. Tasks live inside "nurseries" that own them, so when the block exits, every task it started is finished or cancelled. No orphaned coroutines, no leaked tasks. If you write servers, scrapers, or anything juggling lots of network calls at once, this makes correct concurrency much harder to get wrong. Install is trivial, `pip install trio`, pure Python, no compiler. The real cost is in your head. Structured concurrency is a different model than asyncio, and adopting it means learning to think in nurseries and cancel scopes. It's worth it, but it isn't free. For a new project where getting concurrency right matters, Trio is the clearer foundation, and its ideas were good enough that Python's own asyncio borrowed them as TaskGroups. The catch is the ecosystem. Asyncio is the default, so most third-party async libraries target it, not Trio. You'll lean on the trio-asyncio bridge or Trio-native packages, and sometimes you'll hit friction the asyncio crowd never sees. Pick Trio for correctness, and know you're off the main road.

PureMac5.6k★

PureMac cleans junk off your Mac: caches, logs, Xcode leftovers, Homebrew cruft, mail attachments. Native SwiftUI, zero telemetry, completely free. It's the CleanMyMac alternative that doesn't cost $40/year and doesn't phone home. There's nothing to self-host. Download, install, run. It scans your system and shows exactly what it wants to delete before touching anything. Scheduled auto-cleaning is built in, so you can set it and forget it. macOS 13+ required. This is a personal productivity tool, not an enterprise play. Developers with a cluttered Mac who don't want to pay for CleanMyMac and don't trust closed-source cleaners with full disk access have an obvious choice here. The code is MIT-licensed and publicly auditable. The catch: no malware scanning, no app uninstaller, no smart file deduplication. It cleans known junk paths well but doesn't try to be a full system utility suite.

FxEmbed4.9k★

FxEmbed makes Twitter, X, and Bluesky links render properly when you paste them into Discord or Telegram. Posts that get the silent treatment from social platforms' default embeds (no video, no quote, no poll) suddenly show everything. Type `fxtwitter.com` instead of `twitter.com`, the FxEmbed server resolves the link with full content. MIT licensed. Self-hosting is optional. There's a hosted version that anyone can use for free. To run your own, it's a Cloudflare Workers project: deploy it, point a domain at it. Sub-second response times, no database, no state. Setup is one of the easiest in this list. For people who chat about social posts and want their links to actually render: use the hosted version, no setup required. For privacy-conscious teams or anyone wanting their own instance: self-host on Workers, roughly $0/mo at low volume. It's a workaround for what social platforms refuse to fix on purpose. If those platforms ever build better embed support for outside chat clients (they won't), this becomes redundant. Until then, it's the cleanest fix going.

jupyterlite4.9k★

JupyterLite is Jupyter that runs entirely in your browser, no server. The Python kernel runs as WebAssembly through Pyodide, so notebooks execute locally in the tab. matplotlib, plotly, and ipywidgets all work. You get the full JupyterLab or classic Notebook interface served as plain static files, with your work saved in the browser's own storage. It is BSD-3 licensed and free, part of Project Jupyter. Self-hosting is about as easy as it gets. There is no application server, no Docker, no orchestrator. You build the site once and serve it from any static host, GitHub Pages, S3, Netlify, or a folder on your laptop. Updates are just new static files. The tradeoff lives in the WebAssembly kernel: not every package compiles to Pyodide, and heavy compute runs slower than a real machine. Files persist in browser storage, which means they are tied to that browser and can be cleared. For solo learning, demos, and teaching, this is close to perfect, and it is free. Small teams building interactive docs or sharing reproducible examples get a lot here. Larger teams running real data science workloads still want a server-backed JupyterHub for the compute and shared storage. The catch: it runs in the browser, which is the whole point and also the whole limit. If your work needs packages that do not exist in Pyodide or more memory than a tab can give, this is not the tool.

repowise4.8k★

Repowise gives an AI coding agent a real map of your codebase. It builds five layers of intelligence (a dependency graph, git history analytics, auto-generated docs, architectural decisions, and a per-file code-health score) and serves them to Claude Code, Codex, or any MCP client through nine focused tools. Instead of your agent grepping around blindly, it can ask what is risky here or why this code exists and get a grounded answer. AGPL-3.0, free for internal use. It runs locally: `pip install repowise`, then `repowise init` to index a repo using Tree-sitter across 15 languages. There is no cloud service; it lives on your machine or in CI and exposes an MCP server. Ops is light for a single repo and more involved if you index many large ones or wire it into a whole team's agent setup. The health scoring is deterministic, 25 markers per file rather than an LLM guessing, which is the genuinely interesting part. For anyone running AI agents against a nontrivial codebase, this is a real upgrade to how much the agent actually understands, and it is free for internal use. Solo developers and small teams use it as-is. Larger companies that cannot take on AGPL obligations can buy a commercial license to escape the copyleft terms, which is the only place money enters. The catch is that the impressive numbers (defect prediction accuracy, "2.3x more defects than CodeScene," big token savings) are the project's own, measured on its own test set. They may hold up, but treat them as claims to verify against your repo, not settled fact. The tool is useful for agent context either way; just do not buy the benchmark line without testing it on your own code.

nub3.9k★

nub bundles the tools you already run a dozen times a day into one fast binary: it runs TypeScript files, executes your package scripts, fetches and runs packages from npm, installs dependencies, and manages Node versions. Written in Rust, it's pitched as a faster drop-in for tsx, npx, pnpm run, and pnpm install all at once. MIT-licensed, free, no accounts. There's nothing to host or operate. You install one binary and it replaces a handful of separate tools. The speed claims are real on paper: roughly 3x faster file startup than tsx, much faster script dispatch than pnpm run, and pnpm-compatible installs. It also blocks postinstall scripts by default and checks dependencies against the osv.dev vulnerability database, which is a nice touch most runners skip. Solo: worth a try if your script and install times annoy you. Small teams: same, but pin a version so everyone runs the same toolchain. Large teams: be cautious. This is a young project trying to replace five mature tools, and consolidating your whole dev workflow onto one new binary is a bet on its maintenance. The catch: it is early, and "all-in-one" means a single point of failure for running, installing, and version-managing your project. When it breaks, it breaks everything at once, and you are leaning on a much smaller maintainer base than pnpm or Node itself.

claude-tap3.0k★

claude-tap sits between your coding agent and the API and shows you every call it makes. Point it at Claude Code, Codex CLI, Gemini CLI, Cursor CLI, OpenCode, Kimi, Grok, and more, and it captures and displays the actual request and response traffic so you can see exactly what your agent is sending and getting back. Traces stay local, and it auto-redacts the common auth headers. For anyone debugging why an agent went sideways, this is the difference between guessing and knowing. You stop reasoning about what the agent "probably" did and just read the wire. Free under MIT, install it with uv or pip. Solo developers and teams both get the same thing: full visibility into agent traffic at no cost. The catch is what it is under the hood: a man-in-the-middle proxy on your own agent traffic. That's exactly what makes it useful, but it also means your agent's API calls route through it, so trust and the redaction behavior matter. On your own machine debugging your own agents, that's fine. Just understand what you're pointing it at before you run it against anything sensitive.

panel2.9k★

AcePanel is a server control panel for Linux that manages Nginx, PHP, MySQL, PostgreSQL, Redis, FTP, and SSL certs through a clean browser UI. One curl command to install, single Go binary, runs on basically nothing in terms of resources. The developers explicitly committed to permanently free with no paid tier ever. Installation takes under five minutes on a clean Ubuntu, Debian, or CentOS box. It handles the Nginx configs, database management, FTP accounts, and Let's Encrypt certs that you'd otherwise be writing config files for by hand. Supports both amd64 and arm64, so Raspberry Pi setups work too. Solo developers running a VPS get the full cPanel experience for $0. Small teams managing a handful of web servers get a unified control plane without per-server licensing. There is no paid tier to upgrade to because there isn't one. The catch: documentation is primarily in Chinese. The community is smaller than competitors like HestiaCP or Webmin, and the maintainer team looks small. If you need English-first docs and a large plugin ecosystem, look at HestiaCP instead.

renode2.7k★

Renode does exactly that. Picture a virtual hardware lab where you run your actual firmware binary against simulated chips. built by Antmicro (embedded systems consultancy). Supports ARM Cortex-M/A, RISC-V, Xtensa, and other architectures. You define your hardware in a configuration file: CPU, memory, UART, SPI, I2C, GPIOs, and Renode simulates it cycle-accurately enough to run real firmware. Fully free to use. The license is listed as 'Other': it's the MIT license for most components. Antmicro provides commercial support, custom platform models, and integration services for enterprise customers, but the tool itself is free. Solo embedded developers: run firmware tests without buying dev boards. Small teams: CI/CD integration: test firmware on simulated hardware in your pipeline. Medium to large: simulate multi-device networks and test inter-device communication without a hardware lab. The catch: simulation is never perfect. Timing-sensitive firmware may behave differently on real hardware. Not every peripheral is modeled; you may need to write custom peripheral models for uncommon chips. And the documentation, while improving, assumes you already know embedded development. If you're not writing firmware, this tool has no use case for you.

velxio2.5k★

Velxio lets you write, compile, and run microcontroller code in your browser without owning a single board. Pick an Arduino, ESP32, or Pico, write your C++ or Python, wire up components on screen, and it actually emulates the chip, not a cartoon of it. Under the hood it runs real CPU emulation through projects like avr8js, rp2040js, and QEMU, with a Monaco editor, more than 48 interactive components, a serial monitor, and Arduino library support. For makers and students, that means prototyping before the parts arrive. You can use the hosted version at velxio.dev for free, which is how most people will start. Self-hosting is supported through Docker, but it is a multi-service app, a TypeScript frontend with a JavaScript and Python backend doing the emulation, so it is more involved than a single container. Call it moderate effort to run your own. The license is AGPLv3, with a separate paid commercial license for anyone who wants to use the code inside a closed-source product. That is the key thing to understand: you are not paying to unlock features, you are paying to escape copyleft. The hosted app is free and full-featured. Solo makers, students, and educators are the obvious fit. It substitutes for the paid tiers of Wokwi, and on the desktop side competes with Proteus and the open-source SimulIDE and Renode. The catch is maturity. This is a young project with a solo maintainer, so the bus factor is one and the long-term roadmap is unproven. The simulation is impressive today, but bet your curriculum or your product on it with that in mind.

Observal2.3k★

Observal is a control plane for the AI components your team keeps reinventing. Skills, MCP servers, agent configs, it catalogs them in one registry so people stop rebuilding the same Claude Code skill three desks over. It also records how those components actually get used, with session replay and full traces. Open source under AGPL-3.0, free to self-host. Running it is not trivial. The server is a one-line Docker Compose, but under it sits Postgres, ClickHouse, and Redis, plus domain and secrets config. This is real infrastructure, not a desktop app. Budget a half-day to stand it up and someone to keep it patched. It generates harness-specific configs for Claude Code, Cursor, Pi, and Copilot, so the payoff is a single source of truth across whatever editors your team runs. Solo developers do not need this. The whole point is coordination across a team that has accumulated enough Skills and MCPs to lose track of them. Small teams: worth it once duplication starts costing you. Larger orgs are the target, and that is where the Enterprise Edition comes in, adding SAML SSO, SCIM provisioning, audit logs, and executive dashboards under a separate commercial license. The catch is that Observal only pays off if your team has actually gone all-in on agent tooling. If you have three skills and two MCP servers, a shared folder does the same job. This is for the shop drowning in AI components, not the one dipping a toe in.

clawsweeper2.0k★

ClawSweeper is a GitHub maintenance bot that uses an LLM to identify stale issues and PRs and propose closing them with reasoning attached. It also has a commit sweeper that flags potential issues in code. MIT licensed, free, runs on GitHub Actions or as a GitHub App. Schedule-driven: hourly for hot items, daily for items under 30 days, weekly for older ones. Or trigger it on demand against a SHA range. The pitch vs stale-action and probot/stale is that it actually reads the issue, the PR, and main, then produces evidence ("implemented in commit X" or "duplicates issue Y") instead of closing on timeouts. Pick this if you maintain an OSS repo with hundreds of stale issues and not enough time to review them. Solo maintainers: huge time saver, you only review suggestions. Small teams: same. Large engineering orgs probably build this internally; the public version is geared toward OSS maintenance patterns. The catch: LLM-assisted bots make mistakes confidently. ClawSweeper proposes closures, it does not auto-close, and that's the right default. If you wire it to auto-close, you will lose real bug reports.

pyRevit1.8k★

pyRevit turns Autodesk Revit into something you can automate without a software team. Revit is the heavyweight CAD tool architects and engineers model buildings in, and out of the box, repetitive tasks eat hours. pyRevit lets you write small scripts in Python and drop them into the Revit toolbar as buttons your whole office can click. Free, open source, GPL licensed. Setup is an installer, not a DevOps project, which is the point. You sketch an idea, wire it to a button, and push it to the team through one shared interface. It ships with a pile of built-in tools so you're not starting from zero, and there's a CLI and a telemetry server if you want to manage deployment and usage across a larger firm. The scripting is IronPython or CPython, approachable for someone who isn't a career programmer. This is for the person inside an architecture or engineering shop who got tired of doing the same Revit chore fifty times and wants to fix it. Solo practitioners get the built-in tools for free. Firms get a way to standardize workflows without paying a vendor to build custom add-ins. There's no paid tier, it's free at every size. The catch is the blast radius is exactly one application. If your team doesn't live in Revit, none of this matters. And GPL means anything you distribute on top inherits the license, so check that before you ship custom tools outside your own walls.

dev30001.6k★

Dev3000 is a CLI tool that captures your entire development session: server logs, browser console output, network requests, screenshots, and user interactions in one unified timeline. From Vercel Labs. Free, MIT-licensed. Install via npm or bun globally, run d3k in your project, and it hooks into your Node.js server and browser. AI agents (Claude Code, Cursor, Windsurf) can read the live timeline for context. No persistent server required. The cloud collaboration features use Vercel Sandbox if you need to share sessions. If you use AI coding assistants and spend time context-switching between terminal logs and browser DevTools, this is directly useful. The CLI is free with no limits. Solo developers working with agentic tools are the target audience here. The catch: Vercel Labs means experimental. Headless capture mode has rough edges. Deeper cloud features will likely require deeper Vercel platform integration over time.

mimic1.5k★

Mimic turns any app into a Python library. Point it at an app, it captures the traffic through mitmproxy, pulls out the auth tokens and session data, and uses Claude to generate a plain Python client for the endpoints it saw. Then you import that client and call the app's private API from your own code. MIT, free, from a well-regarded developer. Setup is one script: `sh install.sh` grabs uv, sets up an isolated environment, and bundles mitmproxy so you do not install it separately. The flow is `mimic record` to capture, `mimic hosts` to see what it found, and `mimic gen` to write the client. It works against iOS apps through the proxy and web apps via cURL requests copied from your browser's dev tools. Getting the proxy and device trust set up is the fiddly part; the generation itself is quick. For a developer who needs to script against an app that has no public API, this is a clever shortcut, and it costs nothing. It is a personal-scale tool, not a team platform: no seat model, no hosted service. Solo use is the whole story. The catch is two-fold. Technically, certificate pinning and sender-constrained tokens (DPoP) will block capture on hardened apps, so it will not work everywhere. Legally, replaying an app's private API can violate its terms of service, and the project is explicit that it is for your own accounts only. Use it where you have the right to; the tool will not make that judgment for you.

web-server-chrome1.3k★

Web Server for Chrome is back, rebuilt as "ok200" now that Google killed Chrome Apps. The original author took the old one-click static file server, directory listings, MIME types, ETags, and reworked it into a cross-platform set of tools: a Tauri desktop app, a Node CLI you run as ok200, an Android app, and a launcher extension. It does the simple thing well: serve a folder over HTTP without ceremony. The appeal is exactly what it always was, a static server you can point at a directory and hit from a browser, now living outside the dead Chrome App platform. The old version is preserved on a legacy branch for anyone who still needs it. Free under MIT, for solo devs and teams. It's the graphical, click-to-serve cousin of python -m http.server, npx serve, and http-server. The catch is that it's mid-transition. The original Chrome App is gone, and the replacements are early, the desktop app is around v0.1.5, and the implementation is intentionally spread across TypeScript, Rust, and Kotlin for the different platforms. If you just need to serve files fast, the CLI tools already do it. If you want the polished desktop app experience the Chrome version had, it's still getting there.

buildpacks1.2k★

Google Cloud buildpacks turn your source code into a container image without you writing a Dockerfile. Point them at a Node, Python, Go, Java, Ruby, or PHP app and they detect the language, work out the build, and produce a runnable image. They're Apache 2.0 and fully open source. The important part: these aren't locked to Google Cloud. They implement the Cloud Native Buildpacks spec and run locally through the standard `pack` CLI, and they slot into kpack, Tekton, and Skaffold. So you can use them on your own machine or in CI without touching GCP, even though they're tuned for Cloud Run, GKE, and Compute Engine. The value is skipping Dockerfile maintenance and getting consistent, reproducible builds across a team. If you're deploying to Cloud Run, these are the natural default. If you're not, Paketo buildpacks are the more vendor-neutral CNB implementation and worth comparing. Solo to large teams: useful anywhere you'd rather not hand-tune Dockerfiles. The catch is the tuning. These buildpacks are optimized for Google's platforms, so some defaults assume you're headed to Cloud Run or GKE. For a fully vendor-neutral setup, Paketo is the safer bet. And buildpacks trade control for convenience: when you need a very specific base image or build step, a Dockerfile still wins.

sandboxes879★

sandboxes gives every user a private, throwaway environment where code runs and shows up at a shareable preview URL. It's built for the AI app-builder pattern: a user describes an app, an agent writes it, and it goes live at a link. One Go binary orchestrates Docker containers with automatic preview URLs and TLS, no Kubernetes involved. MIT licensed. The density trick is stop-on-idle and wake-on-request, so a single box can hold a lot of sandboxes without keeping them all warm. OpenCode and Claude Code agents come preinstalled, and there's an HTTP API to create, run, and destroy environments. You'll need a Linux VPS with Docker. The install is one command, but you own host security, scaling, and TLS from there. This is the open alternative to E2B and Daytona, the paid sandbox-as-infrastructure services that AI coding products run on. It also overlaps the backend of app-builders like Lovable, Bolt, and Replit. Solo and small teams prototyping agent infrastructure: self-host it. Teams shipping this to real users: read the security notes first, then decide. The catch: it's days-old beta, and the isolation is containers, not VMs, so the README itself warns it is not safe for running untrusted strangers' code without gVisor, Kata, or Firecracker. API auth is also off by default. Fine for your own agents, risky for a public service as it ships.

make-look-scanned694★

make-look-scanned takes a clean digital PDF and degrades it on purpose, so it looks like it came off an office scanner. Skew, grayscale, paper tone, scanner grain, soft focus, edge shadows, JPEG artifacts. The kind of imperfections that say a human ran this through a machine instead of exporting it from a template. Free and open source under AGPL-3.0. It runs three ways. There is a Go CLI for batch work, a browser version that does everything client-side via WebAssembly, and a single self-contained HTML file you can save and run offline. Nothing gets uploaded; the whole pipeline rasterizes each page to an image and reassembles it locally. Output is deterministic by default, so the same file produces the same result every time. This is a single-purpose utility, and it does its one job cleanly. If you need to submit a signed document that is supposed to look physically handled, or you are testing how a system copes with scanned input, this beats fiddling with image filters by hand. Free for anyone, no account, no limits. The catch is in the output. Because it rasterizes every page to an image, the result has no selectable text, exactly like a real scan. That is the point, but it means you cannot search or copy from the file afterward. And AGPL-3.0 is worth a look if you plan to fold it into a commercial service.