Console

What we like: Use Slack slash commands & reactions to declare and manage incidents & related tasks. Auto-link to PagerDuty, OpsGenie, and Zoom calls. Auto-generated post-mortem with timeline and follow ups (can be linked to Jira, GitHub, Linear). Custom decision flows to script questions that determine critical tasks. Feedback prompt on incident close sharing how it went (optionally anonymously).

What we like: Terminal interface for Docker (containers, compose, images, volumes) - easy to navigate with keyboard shortcuts and much more responsive than the official Docker Desktop app. Quickly access container stats, logs, and execute commands. Bulk commands e.g. stop all containers. Binaries and packages for Mac, Windows, Linux. Open source.

What we like: Very simple CLI for running ping, DNS, TLS, and HTTPS checks against a URL or IP address - useful for quick troubleshooting. Displays the system DNS records for comparison. Configurable output format - text or JSON. Binaries for Mac, Windows, Linux, and packages for Mac and Linux.

What we like: Declaratively build GraphQL APIs. Automatically generate schemas from existing databases (SQL & NoSQL), SOAP/XML, and REST APIs. Schemas defined in config files and can include custom SQL or REST queries to build the endpoint. Built-in directives to handle auth, mutations and pagination. Federate multiple graphs/APIs under a single endpoint.

What we like: Manage dotfiles in Git. Set up profiles to conditionally include specific files on different machines. Jinja2 templates with support for profile specific conditionals, environment variables, .env file for secrets, file/executable path lookups, filters, macros, and user functions. Pre/post execution hooks. Compare/diff before execution. Open source.

What we like: Like jq, but easier to learn. Default behavior is to search rather than transform. Uses ZSON as output by default, which is like JSON but typed. ZSON can be converted to binary or columnar formats for large datasets. Can manipulate data with iterators, count, aggregations, conditionals, sorting, etc. Open source.

What we like: Generates significantly smaller images (example Nuxt app container slimmed from 1.3GB to 122MB). Performs static analysis and runs health checks against your app to ensure essential components are not removed. Config options for ensuring assets are included. Can compare slimmed images using Docker Desktop extension. Also open source as DockerSlim.

What we like: Customize your shell prompt using a range of blocks e.g. clock, AWS profile, Git repo, Python venv, Spotify track etc. Supports themes, fonts, colors, icons, with lots of presets available. Config written in JSON, but also supports TOML and YAML. Supports right-aligned tooltip-like prompts for extra info. Works on macOS, Windows, and Linux.

What we like: Runs HTTP, TCP, Shell, SSH, and client connection (e.g. MySQL, Kafka, Postgres) health checks, and collects hosts (CPU, memory, disk) stats. Triggers notifications via common services (Slack, email, SMS, etc). Can report SLAs. Runs as a single (Go) binary. Open source.

What we like: Search backend optimized for large volumes of append-only data with relatively low-QPS (<10 average), most commonly logs. Data in S3 object storage which reduces cost and inherits reliability and scalability. Search instances are stateless. No GC (implemented in Rust). Open source.

What we like: Runs as an extension of k8s with workloads executing inside containers, which means you can deploy CI/CD anywhere k8s runs. Scales by adding cluster nodes. Lots of community contributed tasks and pipeline components e.g. golang build or create Buildpacks. CLI is the primary UI, but also exposed via a web dashboard, kubectl, and an API.

What we like: Provides a visual terminal interface for GitHub PRs and Issues. Sits on top of the official GitHub CLI so no need for extra auth etc. Customizable filters (using GitHub standard filter syntax). Preview description plus comments.

What we like: Search backend as a single (Rust) binary. Gives you search as you type, typo-tolerance, synonyms, highlighting, filters, facets, sorting, and phrase search via a REST API. SDKs for a large number of languages, frontend, and backend frameworks. Includes a simple search web UI out of the box.

What we like: Create APIs (internal, public, authenticated) from annotations on standard functions. Databases, queues, scheduled tasks are native code primitives. Builds, deploys, tracing and logs built in. Provisions local and/or cloud test/dev environments. Open source, use your own cloud (AWS, Azure, GCP), or the Encore cloud.

What we like: Simple CLI for generating file-based changelogs separate from commits. Using files means changelog entries can be part of diffs. Customizable templates for standardizing input of different types of changes e.g. bug fix, feature, deprecation. Command to merge all changes into a single file.

What we like: Acts as a layer on top of the GCP products e.g. Firestore, Cloud Functions, so you can always “break out” to use the full cloud functionality. Easy to create UIs with field types, JOINs across tables, custom code functions executing on data, or external web services. Write functions in JS and use NPM modules. Open source.

What we like: Script desktop UI actions - mouse, keyboard, clipboard, windows and what is on screen. Supports macOS, Windows, and Linux. Trigger keyboard shortcuts, input text, find images, click and drag actions. Useful for UI testing or automating common actions. Open source.

What we like: Interactive CLI to combine previously executed commands into a new shell function. Shell agnostic. Generated functions are written to a plain text file which can easily be stored in Git or cloud storage.

What we like: Built-in auto complete for common commands and options. Output contained within blocks which can be navigated with keyboard shortcuts, easily copied or shared using a web link. Input is a proper text field e.g., easy input for multiple lines, select text, dual cursors, etc. Dark/light mode theme sync. Command palette.

What we like: Like running your own local GitHub Codespaces - containerized environment with an IDE attached (uses Theia). Or host in the cloud for team access. IDE is VS Code compatible, runs in your browser. Specify Docker images to launch, or use your own. Quickly spin up new containers for different environments, with RBAC and HTTPS endpoints

What we like: High performance high availability datastore with fully synchronous transactions and non-blocking two phase commits within a single cluster. Async replication between clusters. Scales linearly with CPUs. Queries automatically parallelized. MySQL (NDB) compatible interface with many native language SDKs. Open source.

What we like: APIs for all the logic around sending notifications. Batching allows triggers to be aggregated into a single notification e.g. many recent comments on a doc into a single email. Supports email, SMS, push and chat notifications, plus in-app feeds. State sync for read status plus notification delays e.g. send email if not read in-feed after 30 mins.

What we like: Everything is included - no need to install extra plugins. Supports fuzzy search, buffers, language server with syntax highlighting, suggestions and auto indent. Easily discoverable commands. Powerful text manipulation via selection then edit. Clipboard integration. Built-in themes. Open source.

What we like: Define type-safe APIs in TypeScript to avoid code generation by sharing types between client/server. Includes adapters for major frameworks e.g. React, Next, Express. Built-in query batching and caching. Supports middleware, logs, WebSockets, and Subscriptions. Supports data transforms e.g. superjson to use standard types over the wire.

What we like: Generates realistic fake data through analysis of the real data. Understands field types with a large range of generators e.g. addresses, cross-table sums, UUIDs, etc. Can implement differential privacy and statistical relationships between fields / foreign keys. Maintains consistency through constraints, cardinality and duplication. SaaS or on-prem.

What we like: Supports OpenTelemetry, Jaeger and Zipkin plus agent-based SDKs for Java, Go and Python. Cloud native design running inside k8s with Helm Charts. Built-in UI for global health, services, metrics, traces and logs. Processes events in real-time without sampling. Open source.

What we like: Native client (not Electron) for PgSQL, MySQL, Mongo, Redshift, and others. Query log shows SQL behind the scenes. Visual row and table editor makes it easy to select field types, alter structure, search/filter, and input data. Can preview changes and SQL before it executes. Inspect DDL for schemas. CSV/SQL import/export. Mac, Windows, iOS.

What we like: Handle events from a large number of sources - HTTP endpoints, databases, services like Docusign, Zoom or Google Drive. Chain steps to manipulate source data - send emails, update Google Sheets, insert into database. No-code web editor to query source fields. Use pre-built modules or write code and use packages in custom steps.

What we like: Easily run common actions visually - stage (individual lines, files, everything), commit, stash, review logs, interactive rebase, undo/move commits or patches - with just a few keyboard shortcuts. Cherry pick commits to other branches. Uses default terminal theme, also customizable. Binaries and packages available for every platform.

What we like: Define all the containers and services in complex (microservices) applications to manage local dev with a single `tilt up` command. Config file uses a dialect of Python so it can be programmed. UI to manage all running services - get endpoint, view status, tail logs, create your own actions. Supports live updates/rebuilds. Open source.

What we like: Building blocks to make it easy to create collaborative applications e.g. multiplayer documents. APIs convert JS objects, lists and maps into CRDTs with managed sync of changes, conflicts, and offline support. Handles persistence of documents. REST API or SDKs for React, Zustand, Redux, Node.

What we like: Allows querying different file types with SQL e.g. CSV, JSON, Parquet, Excel, Apache/Nginx logs. Uses SQLite under the hood. Supports multiple files as “table”, and joins between them. Query nested objects.

What we like: SSH keys securely stored in Apple’s secure enclave. Works with git, SSH connections, etc. Authenticated via macOS, which allows you to use Touch ID and Apple Watch. Native management GUI. Open source.

What we like: Highlights dev-related articles based on customizable topics. Web version or replace browser start page (Chrome, Firefox, Edge). DND mode to avoid distracting articles during specified times. Bookmarked articles available as RSS and can be committed to GitHub. Open source.

What we like: Option for self-hosted (via a Docker container) or cloud service. Supports many different analytics datastores so existing data can be used to run experiments e.g. Redshift, Snowflake, ClickHouse, Postgres, MySQL. SDKs for running experiments from code. Jupyter notebook export.

What we like: Static (Go) binary makes it easy to install anywhere (also in major package managers). Splits, tabs, discoverable keybindings, multiple cursors, mouse support (selecting!), color themes, diff gutter, auto-complete, syntax highlighting, system clipboard integration, linting, macros.

What we like: Integrates with VS Code and JetBrains IDEs to link issues with code. Issues highlighted with the currently open editor with indicators on the relevant lines of code. Syncs with JIRA, GitHub Issues, Linear. Tracks TODO comments across the codebase.

What we like: Bootstrap and manage isolated dev environments tied to the code e.g. specific versions of Go, Rust, Node, GNU make, etc. Config (and packages) defined in HCL. Supports private packages. Can define environment variables. Runs in CI. Hooks into your shell for auto-activation of environments.

What we like: Easily query HTML using selectors such as IDs, attributes, text filters, and nodes. Can perform actions like returning all links, extracting text, removing nodes. Pretty print HTML. Open source. Packages available for Mac, FreeBSD, Windows.

What we like: Provides REST (default) and GraphQL (via a plugin) APIs to your content. Choice of backing datastore - defaults to SQLite; MySQL, Postgres, MariaDB also supported. Admin panel is “static”, so can be deployed anywhere that can serve web requests e.g. S3. Can also use S3 for handling media uploads. Open source.

What we like: Can run migrations as SQL files on disk or embedded into Go functions. The latter means you can ship a self-contained binary to run migrations with no dependencies. Supports out of order migrations. Good DB support: Redshift, MySQL, Postgres, Clickhouse, and others.

What we like: Finder integration shows file status badges. Can open and manage GitHub, GitLab, BitBucket PRs from the client. Repo browser with history timeline, tags, remotes, branches. Use the built-in diff viewer or launch your own. Point & click GUI or do everything via shortcuts.

What we like: Go back in time and add debug statements, inspect React components, access browser devtools and network requests. Record automated tests (Playwright, Puppeteer) to get replays for failures. Clever implementation means (non-deterministic) inputs are recorded rather than every system call (significantly reduces overhead and allows for replaying state at all points in time).

What we like: Pretty-print JSON files. Expand/collapse objects and arrays. Vim-inspired commands make navigating easy e.g. move around nodes and siblings, focus on lines, scroll by characters or lines. Uses native shell colors. Regex and full text searching.

What we like: Interactive terminal interface for managing Docker - list, search, tail logs, stop, star and enter shell for any locally running containers. Shows basic stats e.g. CPU utilization, state and status. Inherits native shell colors.

What we like: Analyze code via CLI, IDE and/or CI/CD for rule compliance e.g. deprecate APIs, enforce coding standards, detect common security issues (OWASP 10, etc). Understands meaning of code, not just rules by text matching, Large number of community rules for common scenarios. Open source + cloud version for team features.

What we like: CLI-first interface. Deploys apps from a Dockerfile to global locations, but they actually run on Firecracker VMs. Scale up app instances with 1 command (or use auto scaling). Internal IPv6 networking with clever address routing to discover instances (which you can connect to via Wireguard). Managed Postgres with HA & read replicas.

What we like: Built in community cheat sheets auto-downloaded for all major Unix commands - quickly get access to examples of the most common options. Create your own, then add tags and paths. Phrase search within. Autocompletion for bash, fish and zsh.

What we like: Can connect to REST APIs and import API specs e.g. Swagger/OpenAPI 2.0 to automatically connect the UI to the data (or databases and CSV). Can create custom views with filters, grouped or calculated fields from data sources. Multi-step automations to process data. Supports dark mode. Open source or cloud service.

What we like: Quickly execute scripts from an Alfred/Spotlight type launcher. Scripts written in JS to perform actions like search APIs, launch apps, resize images, manipulate strings - anything you can do with Node.JS (including npm support). Built-in UI for script inputs. Add keyboard shortcuts.

What we like: List all Git repos in a directory and view their status, branch, staged/unstaged changes and last commit message. Color coding shows status compared to remote. Can add flags, list by flag, group, list by group. List repos in a config file then clone them all at once. Batch execute git commands across all/grouped/specific repos e.g. git pull on all repos.

What we like: Go binary or run as a container (includes official Helm chart). Resize images via URLs, which can (and should) be signed. Can serve files from cloud storage (S3, GCS, etc). Can compress, crop, fill, blur, watermark and convert to desired formats. Emits metrics to Prometheus, New Relic & Datadog. Open source.

What we like: Designed to work particularly well for use cases with lots of similar files that don’t change often. Snapshot command stores the state of the current working directory - execute as you make changes like a git commit. Pack command compresses the snapshots. Very fast snapshot extract. Open source and works on Windows, Linux, macOS.

What we like: Work with field names rather than positional indices. Add new fields, run aggregations, colorized, tabular pretty-print. Operates with streams so only a single record is in memory at one time (unless needed for certain operations like sort) i.e. minimal footprint. Single binary (Golang, open source) with packages for Windows, Linux, macOS.

What we like: Docs live as Markdown in the code repo. Smart editor links snippets and references even through refactors, moves, renames, etc. Plugin for VS Code and JetBrains editors to render docs in-line/. Integrate with CI (or Git hooks) to get PR comments and a quick edit link when docs need updating.

What we like: Provides an HTTP API with caching, pre-aggregation and SQL support on top of popular datastores e.g. Postgres, Redshift, BigQuery. Visualization libraries provided for D3, Vue, Angular, React. Local “playground” UI makes it easy to debug queries. Open source (including cluster mode for scaling). Optional cloud version.

What we like: Simply watch files and execute commands when changes are detected. Specify files, filetypes, directories, filters/ignores (including .gitignore). Can issue command restarts e.g. for servers. Runs commands in a shell, which can be specified (or set to no shell).

What we like: Snapshots allow you to visualize changes in cloud resources. Provides security and compliance suggestions, which can be exported to CSV. Search and filter resources which are highlighted in the map view. Provides a GraphQL API for your cloud resources. Open source backend with CLI.

What we like: Manages WIP branches and makes it easy to hand over development to your programming partner(s). Makes it easy for multiple people to simultaneously contribute to a coding session. Built-in timers. Squashes commits by default. Single binary CLI with packages for macOS, Windows, Linux (including Arch & Nix).

What we like: Gradual install so you can slowly roll it out to different parts of your repo. Pipelines defined in package.json. Caches based on hashes so builds are incremental, which also includes logs and emitted files, making builds much faster. Supports remote caching that can be shared using content addressable storage.

What we like: Simple CLI for automating testing for memory leaks, primarily relevant for SPAs. Examines objects, event listeners, DOM nodes and collections. Default test scenario does most of what you need, but custom scenarios can be defined e.g. custom setup to log into an app. Has an API.

What we like: Commits uncommitted changes every 5 sec to a separate branch without affecting HEAD, the current branch or staged files. Use standard git commands to switch to the Dura branch if you need to recover. Can watch multiple directories.

What we like: Not as fiddly as curl - can use shorthand URLs and it’ll do the right thing (HTTPS by default if using xhs binary). Can ask it to output the curl equivalent command if needed. Easy to specify body parameters, query strings, set request headers, get response headers. Response colorized by default. Packages for most systems (Mac, Linux & Windows).

What we like: RBAC for remote login to servers (SSH), databases, k8s, desktops and internal web applications. Uses cert-based access control with 2FA rather than passwords or keys. Records all sessions automatically. Teleport SSH server compatible with OpenSSH so you can use any client (including a web client). Open source - deploy self-hosted or via cloud.

What we like: Use regex syntax from JS and Python rather than figuring out sed and awk. Find and replace using string-literals to avoid regex entirely. Simple syntax for in-file operations, including preview changes. Simple replacements on large files significantly faster than sed. Cross-platform support with packages for common OSs.

What we like: Sits on top of S3-compatible object storage and acts as a copy-on-write management layer/proxy. Create branches of data e.g. to run tests, upgrade tools, migrate schemas, etc without risking the data. Atomic merge avoids bad states and allows rollbacks. Can ingest existing data without copying it.

What we like: Auto-suggests initial tests. Config and tests are code. Either run as a CLI with all analysis done locally, or as a Python library to programmatically test data. Configurable expected error rate before erroring. Works alongside Airflow, Dagster, or dbt to support scheduled tests. Open source - cloud service optional (alerts and reporting).

What we like: Easy to create a replicated (sync or async) in-memory cache across distributed nodes. Can be used as a client/server (language independent & horizontally scalable) or as an embedded Go library (lower latency). Supports topics and listeners for distributed event processing.

What we like: Dependency free - lightweight total size. Everyone needs a datepicker eventually and the UX is always difficult to get right. Support for all major browsers going back to very old versions. Date, time, date range selection. Libraries for React, Vue, etc. Supports localization and themes, including a dark version.

What we like: Makes terminal cheat sheets from tldr available offline (cached) with common examples for how to use the specified command. Colorized output uses your shell color preferences. Open source, cross platform and packages available for most systems.

What we like: Designed to be invoked via client libraries so the test conditions can be deterministic and programmatically defined. Simulate latency, timeouts, peer resets and other weird network conditions. Can be configured to introduce randomness. Official clients for Ruby and Go (other community clients available)

What we like: Markdown-based editor with custom dev-docs focused components e.g. diagrams, multi-language code blocks, GraphQL / OpenAPI endpoint blocks, changelogs. Build internal or public docs. Publish multiple doc versions e.g. for different API versions.

What we like: Define rules and automations in code based on conditions for approvals, assignment, merges, rebasing, reviews, queueing and prioritization. Can examine attributes like task list status, PR dependencies, Dependabot, Snyk and other tool integrations. Engine is open source.

What we like: Code samples can run locally in the browser (using WebAssembly). Can be embedded into a web page using an iFrame or web component. Enable editor to allow the user to modify and run the code. Sandboxed and runs in a terminal emulator.

What we like: Lots of plugins for sources e.g. AWS S3, Apache, StatsD, stdin; transforms e.g. aggregate, filter, log to metric; sinks e.g. Cloudwatch, Prometheus, Elasticsearch. Makes it easy to create a consistent pipeline even as sources and sinks change - no lockin. Can run as a single agent, sidecar or as an aggregator cluster for more throughput. Open source.

What we like: Manage your packages across all repos from a single service (RPM, Deb, RubyGem, PyPI, NPM). Web UI or CLI to push new packages. Create private repos for internal packages. Auto-generates install scripts for users. Integration with CI to easily push packages on build.

What we like: Project-based and sandboxed, which makes it safer to use it to try third-party projects. Config is code (Starlark) - no arbitrary flags, env vars, etc, so the result is much more predictable. Inputs/outputs are content addressed, hashed and cached (or built from source) which then makes them reproducible.

What we like: Quickly show possible performance problems in your HTML <head> such as blocking JS, redundant calls, third-party stylesheets. Either drop in a CSS stylesheet or run the JS snippet for any page using browser devtools.

What we like: Use GraphQL to query resources. Queries run against a cached database which you can scale yourself, avoiding AWS limits. Consistent interface across products - avoid complex JOINs. Query historical state because data is versioned. Bundled UI with autocompletion and schema explorer.

What we like: Quickly search and filter system and user units. State view shows service metadata plus recent logs. Shortcuts for filtering by state and reloading. Prompts to run relevant commands.

What we like: Significantly speed up common git tasks with shortcuts. Improved version control view with show/hide diff, easily stage individual files or multi-select changes. Stage chunks of changes. Forge mode provides extra context from GitHub e.g. issues, PRs.

What we like: Displays real-time stats as tests are executed, both on the CLI and via a web UI. Reports latency, req/s, errors, read/writes. Includes latency histogram and percentiles. Supports all HTTP verbs including reading in POST data from a file. Dockerfile provided.

What we like: Runs a full version of SQLite entirely in the browser. Can load DB files from a URL or a file. Can optionally sync with GitHub to save data and queries in plain text. Easy to share via a link. There is no server. Open source.

What we like: Implements automated delivery from Git to k8s. “giterminism” concept provides reproducibility without external config dependencies - everything is based on the git repo. Handles Docker image builds, k8s rollout and cleanup. Can be embedded in existing CI/CD pipelines. Generates and manages Helm templates.

What we like: Automate tedious incident handling workflows e.g. create new Slack room, status page update, create Zoom bridge. Inventory catalog assigns teams and aggregates useful tools (e.g. PagerDuty on call, Datadog dashboard, last GitHub event) for quick lookup during incidents. Auto-generate timelines based on chat logs, events, actions to make retrospectives easier.