Console

What we like: Config is defined in a TS|JS|YML file in your code repo. Query caching is automatic, but can be made smarter by syncing the schema (via CLI or CI). Fine-grained cache rules per type or field. Cache invalidation can be based on TTL or mutations. Supports query batching without any server-side changes.

What we like: Simple CLI to run scripts across multiple Git repos or all repos in an org. Can run a shell script or run code through a runtime e.g. Python or node. Clones the repo, runs the script, then submits a PR with the changes. Can run against branches. All configurable e.g. PR title and description. Open source.

What we like: Builds on standard web APIs e.g. Fetch and Form rather than custom implementations. Clear separation between client and server with strong preference for server-side rendering. Progressive enhancement - JS not required. Performance focused by only reloading what has changed. TypeScript by default. Accessibility built in.

What we like: New passwordless feature enables WebAuthn e.g. Apple TouchID, FIDO keys, etc, to authenticate users. Users can be provisioned on demand e.g. assuming a particular role with restricted permissions. “Just in time” access requests via tickets (JIRA) or chat (Slack) for approval flows. All this helps implement concept of least privileged access. Open source.

What we like: Very lightweight and minimalist. Syntax highlighting for lots of formats. Basic content parsing e.g. highlighting matching braces. Supports splits. Has themes, or just uses macOS default look. Text editing features like outline, snippets, smart substitutions. Implemented in Swift and open source.

What we like: Auto-detects which package manager you should be using from npm, yarn, pnpm, or bun. Supports install, run, execute, upgrade, uninstall, and clean install which adds common arguments for each of the supported package managers. Also has an alias command so other raw commands can be executed.

What we like: Single view of all assets across AWS, GCP, Azure, k8s, Datadog, Okta. Highlights (and can alert on) assets not managed by IaC e.g Terraform or that have drifted from the expected state. Auto-generates Terraform and Pulumi (TypeScript) code representing those assets. Reports common issues e.g. publicly accessible S3 buckets or instances with public IPs.

What we like: Provides Git-like commands for data, mapped to SQL e.g. writes are staged, then committed. You can work on branches, diff the working set and revert changes for both data and schema changes. Fully MySQL compatible so any MySQL client will work. Work from a Git-like CLI or with SQL commands that act on system tables or stored procedures.

What we like: Easy to use CLI which scans the specified container image for OS and language vulnerabilities. Supports various major container OSs e.g. Alpine, Debian, Distroless, Ubuntu. Scans packages from languages (Ruby, Java, JS, Python, Dotnet, Golang, PHP, Rust). Configurable ignores, output formats, and vulnerability data sources.

What we like: SDKs (Node, Ruby, Python, Go, Java, etc) to make it easy to add SSO, MFA, directory sync and audit logs to your app. Also supports email magic links and OAuth via Google & Microsoft. Admin dashboard for your users to configure their SSO settings so you don’t need to build it.

What we like: Auto-generates a REST backend based on your Postgres data schema with TypeScript definitions. Schema designer includes common patterns e.g. foreign key constraints, Postgres Policies for access control, cascading delete actions. Handles schema migrations. Open source.

What we like: Provides remote cloud dev workspaces - SSH and code remotely e.g. with Vim or Emacs, connect your IDE e.g. VS Code or Jetbrains. Forward ports to localhost so runtimes & servers etc can be accessed as if local. Share URLs and setup scripts so environments can be reproduced/accessed by others. Manage via CLI or web UI.

What we like: Easily copy production databases to dev. Exclude data from certain tables (but maintain the schema). Transform or reduce data to redact private data (replacements are consistent across snapshots) with custom JS. CLI for restoring snapshots to your local DB. Can choose to restore all data or specific tables.

What we like: Incredibly lightweight (3MB) because it focuses on just text editing. Good font rendering. Themes and syntax highlighting out of the box. Splits, global find, multi-cursor editing. Command palette. Cross platform - Windows, macOS and Linux. Decent plugin ecosystem. Open source.

What we like: Makes it easy to manage tags in Terraform from a single CLI. Cascade tags/labels to AWS, GCP, and Azure. All managed via templates so they can be added, updated, removed at any time. Recurse directories of Terraform configs. Open source.

What we like: Connects to any SQL database and provides an API (REST, GraphQL), JS SDK, a CLI, and a web UI. Provides an analytics dashboard from your data. Configure web hooks on write events. Data flows can trigger on events, transform data, perform actions e.g. send emails, send webhook. Supports SSO & RBAC. Open source.

What we like: Provides an overview of local and remote origins, tags, submodules and code hosting features like PRs, issues, and CI/CD e.g. GitHub Actions. Use the GUI alongside the built-in terminal, or switch it to CLI-first, which provides enhancements like a visual tree view and autocomplete/suggest. Supports Mac, Windows, Linux.

What we like: Toggleable real-time visual panels for CPU (per core), memory, disk and network resource consumption. Process list with filters and per process detail view. Option to kill processes or send signals. Graphical visualization of activity per core, CPU and network tx/rx. Option to inherit shell theme. Open source.

What we like: Slack chatbot for running dev processes. Supports common tasks like managing open PRs, reminding people assigned to tasks, changing linked JIRA ticket statuses, getting a morning task summary. Reminders sent as normal Slack messages so full chat context can be maintained. Team leader view shows open tasks across all team members.

What we like: Makes listing files much better - uses shell colors, shows Git status, optionally shows file type icons, human readable file sizes, useful defaults for showing metadata in long view. Tree view for recursing into sub directories. Can sort and filter using globs and gitignore. Executes queries in parallel. Open source.

What we like: Declaratively manage Git hooks in a single config file. Handles installing runtimes and dependencies e.g. Node for a hook script written in JS. Clean output which shows pass/fail status of each hook when triggered. Configure files, excludes, filetypes, that it will run against. Open source.

What we like: Makes it easy to replace ad-hoc scripts. Interact with SQL and REST APIs. Build tasks in the web UI and combine them with Node, Python, Shell, Docker or no-code blocks. Tasks can be defined in YAML, exported, imported and executed from a CLI. Self-hosted agent allows tasks to run within your own environment/network. Slack integration for approving executions.

What we like: Lightweight CLI that uses fzf to make Git commands interactive - add, log, reset, checkout, branch, revert, stash, rebase, commit, and others. Triggered via short character aliases e.g. `ga` for `git add` or `gc` for git commit. Has keyboard shortcuts. Inherits shell colors. Open source.

What we like: Install and run macOS, Windows, Linux guest VMs with macOS as the host. Supports both x86 and ARM images. Automated download and installation of common images, including macOS guest. Uses native UI and virtualization framework which offers the best performance. Open source.

What we like: Single CLI that runs all your linters and formatters. Doesn’t reimplement existing tools, but consolidates settings, versions, rules into a single config. Can auto-fix problems. Operates on changed files by default, so you can gradually roll it out across existing code. CI/CD integration. Optional web UI to track trends.

What we like: CLI to stream logs from AWS Cloudwatch for one or multiple log groups/streams. Filter based on timestamp. Supports grep, invert grep, and the AWS CLI --query flag (JSON queries). Convert timestamps to UTC or local. Uses AWS CLI credentials (including SSO). Open source.

What we like: Define steps which are then run inside a container e.g. build code, run a server, execute commands. Choose which Docker image runs the tasks. Tasks can define dependencies on other tasks. Mount paths. Local and remote caching. Can run on CI - feels like GitHub actions, but portable.

What we like: Defining the UI server-side allows updates without a new app version. Visual editor converts the UI into SwiftUI and Jetpack Compose components on-device, so the user experience is native. Proper support for dark mode, a11y, i18n, etc. Can connect to arbitrary REST and GraphQL endpoints. Can export raw SwiftUI code.

What we like: Simple terminal UI for undoing common git commands (commit, add, push, branch -D, pull, reset, tag, stash, merge, cherry-pick). UI makes it easy to pick the correct action. Doesn’t do anything fancy underneath - executes the commands you’d have had to search for.

What we like: High performance file search. Default syntax is easy to remember - case insensitive by default, enabling case-sensitive if the pattern demands it. Search by regex, directory, extension, glob. Optionally execute commands with results (individually, or as a group) e.g. to remove or tar files.

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).