Console

What we like: Manage CI/CD, seed data, dev preview environments, and prod infrastructure from a single config file. Makes it easy to spin up new feature branches with duplicate infrastructure in separate cloud projects. Provides VS Code web instances for cloud-based dev against fully configured environments. Supports custom VS Code/vim/emacs configs.

What we like: Framework agnostic CSS variables with minimalist styling for all HTML elements. Includes dark+light mode. Supports CSS, PostCSS, JSON, or props as Javascript. Covers colors, gradients, typography, animations, media queries, and masks. Available via NPM, CDN, or CLI. Open source.

What we like: Native (Swift) terminal emulation and SSH client for iPhone/iPad. Generate device specific keys stored in the secure enclave (or sync keys + settings over iCloud). Store a series of commands as snippets for easy execution. Built-in session keepalive via an agent or Tmux. Lots of themes. Env vars. PowerShell for Windows hosts.

What we like: Augments OpenTelemetry to integrate logs and remote calls. Traces are visualized step by step, which makes it easier to understand the flow. Splits out each remote call e.g. HTTP or Kafka to show all parameters and attributes. Generates replication code for each call to reproduce issues. Integrates with CI to provide build failure visibility.

What we like: Visualizes the output of continuously executed shell commands. Build a dashboard of charts, sparklines, barcharts, gauges, text, and ascii components. Managed via a config file. Perform conditional actions e.g. terminal bell or exec command. Can connect to databases, Docker, and SSH. Open source.

What we like: Menu bar app to show notifications from GitHub and Linear. Keyboard shortcuts for all actions (including a global keybinding to show the UI). Preview full notification without marking as read. Mute options to filter by user, repo, notification type.

What we like: Single API/SDK for pub/sub, queues, and streaming. Handles global distribution, scaling, and availability with latency-based routing. Client connection recovery with replay and queuing for disconnected clients. Official SDKs for most major languages & compatible with MQTT, AMQP, STOMP, REST, SSE, XHR, JSONP, Kafka, SQS, webhooks, and other integrations.

What we like: Web testing with full devtools on multiple devices. Simulate slow/mobile network connections, OS chrome, responsiveness, color schemes, locale, with cursor, nav, input, and scroll sync. Test OG social previews (Twitter, FB, Google, Slack), override fonts and styles. Take screenshots, gifs and videos as if on the device.

What we like: Simple CLI which analyzes code for secrets. Can run on standalone directories or files as well as Git repos. Scanning repos includes the full history - a baseline can be set to scan from, excluding prior commits. Official GitHub action. Open source.

What we like: Provides a single user ID for purchases & subscriptions across app platforms (Apple, Google Play, Amazon, Stripe/web). Single subscription backend & mobile SDKs with analytics e.g. customer count, MRR calculation. Event webhooks and data/ETL integrations with third-parties like S3, Firebase, Intercom, Slack to take actions on subscription events.

What we like: Secure Git-like method of syncing .env secrets. Team access with permissions per environment makes it easy to give access to different resources. Direct sync with infra e.g. Vercel, Netlify, GitHub, AWS, or dotenv CLI. Version history for secret values allows for rollbacks. VS Code extension.

What we like: Full terminal emulator with built-in SSH client. Configure themes, fonts, scrollback, bell, and shortcuts. Built-in tabs and splits (which are remembered with session history on restart). Quake mode global shortcut to show/hide terminal. Notify on process completion. Cross-platform + web client (beta). Open source.

What we like: Drop-in spreadsheet-like UI for Firestore. Typed fields e.g. dates, checkboxes, uploads, Markdown, JSON. Supports cloud functions workflows on field changes. Integrates with SendGrid, BigQuery, Twilio. Can pull in data from HTTP endpoints or import CSVs. Table/field-level RBAC. Dark mode. Open source.

What we like: Fulltext search without any backend infrastructure - indexes the output of static site build process i.e. the HTML. Integrate with your site using a provided UI component or with the JS API. Supports string or array filters and search across multiple sites. Static binary with no dynamic dependencies.

What we like: Inspect, tail, write to, or redirect events in message queues. Supports a wide variety of queues e.g. Kafka, RabbitMQ, SQS, NSQ, GCP Pub/Sub. Pipe messages into the queue. Can decode various message formats in real-time e.g. protobuf, JSON, etc. Single binary for macOS, Windows, Linux.

What we like: Easy, but flexible CLI for running scripts as commands, which are stored in a `justfile` i.e. per project/directory. Commands can take arguments and load .env files. Write commands in arbitrary languages e.g. JS, Python, Ruby. Editor plugins for Vim, VS Code, JetBrains, etc. Proper error handling. Works on Mac, Linux, Windows.

What we like: Run independent backups that would otherwise be a pain to deal with e.g. offsite AWS, GCP, DO volumes, MySQL, MongoDB, Postgres databases. Serverless backup runner or hosted on your own instances. Bring your own storage e.g. S3 (or any compatible), Google Drive, Dropbox. Can also backup apps like WordPress and repos from GitHub.

What we like: Real-time view of your k8s cluster in a TUI. Provides a high level view of deployments, sets, pods, jobs, volumes, CPU, memory, etc. Drill-down views with more details and related resource usage. Log streaming view. Run commands e.g. scale, shell, kill. Keybindings, plugins, themes. Works on Mac, Linux, Windows.

What we like: Generates visualizations of code relationships to help understand how the codebase works. Create visual tours of code to help onboard new engineers or document functionality. Maps are posted to pull requests like a visual diff of what was changed and can be used to tour the changes in logical order. Maps auto-update with commits.

What we like: A full Postgres instance compiled to WASM and running in your browser. Provided as an ephemeral playground which makes it easy to test commands and learn how things work. Several tutorials provided, including for features like partitioning and PostGIS. Interact via psql CLI.

What we like: Hooks into your shell to auto-load/unload environment variables when you cd into a directory. Loads a simple .envrc file in each directory. First-run in each dir asks for permission to mitigate malicious execution. The .envrc file can just be a list of exports, but it is also a bash script which allows you to execute other code. A useful stdlib of utility functions is provided.

What we like: Combines markdown notes with a collaborative whiteboard. Developer specific components such as code blocks, browser frames, tech related icons, and sequence and entity relationship diagrams defined in code. Notes can link to specific areas of canvas. Keyboard commands for most actions. Signup not required.

What we like: Can manage schedules from whichever calendar you already use e.g. Google Calendar. Ingests alerts from a wide range of sources including Grafana, Prometheus, AWS, New Relic, Datadog. Handles rotations, overrides, upcoming shift notifications, and escalations. Configs can be managed in Terraform. Open source.

What we like: Supports Cloudflare Workers, Deno, Bun, Fastly, plus anything else that supports Web Standard API, which makes it simple to use and (mostly) works cross-platform. Built-in middleware for auth, cache, CORS, JSX, logs, JWT, JSON and static assets. Written in TS so you get proper types. Open source.

What we like: Automate chaos testing in k8s, Docker, and Linux environments. Run experiments such as shut down instance or pod, simulate packet loss, drop DNS requests, and stress CPU. Control what is affected by attributes such as cloud zone, pod name, % of containers, etc. Simulate rippling outages across multiple applications. Trigger and monitor tests via CI/CD.

What we like: Provides a suite of tools for creating flame graphs, profiling CPU, GC, memory allocation, and async calls. Docs do a good job of walking through what the output means and how to solve common problems. Visualizes how async calls chain together and where time is spent. Open source.

What we like: Easier to work with than UUIDs e.g. you can double click and copy them from a URL. Uses more (configurable) characters than UUID so the ID size can be reduced (also configurable). Faster to generate than UUID. Collision probability can be calculated based on config values so you can trade off usability for chance of collision. Available for lots of languages.

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