Console

What we like: Can be used as a database server or as a library. Acts as a k/v store or can be queried using SQL. Storage agnostic - can even be S3. Built-in Prometheus endpoint. Can disable synchronous indexing to increase performance. Supports PostgreSQL wire protocol. Interesting use case as a secondary database for cryptographic verification of the primary.

What we like: Supports input from a file, URL or stdin so it can be piped to grep and properly searched. Allows the full path to be revealed. Colorizes output. Easily diff sets of JSON. ungron reverses the conversion, so you can pipe grep results back to JSON. Cross-platform binaries available for Windows, Linux and Mac.

What we like: Allows you to move between stacks of commits without using branches. `git move` is implemented in-memory so is faster than `git rebase`, which works on-disk. Interactive `git undo` command helps fix commits, merges, rebases, checkouts and branches. Smartlog command visualizes work without branches (unlike `git log --graph`).

What we like: Lots of desktop and mobile browser versions, including very old devices and new betas. Can write tests in open source Selenium or Cypress frameworks. Tests can be automatically compared against previous runs. Integrates into CI/CD to detect regressions. Geotarget features can test localization e.g. currencies, time zone changes etc.

What we like: Displays line numbers. Side by side view. Can be used independently from the terminal, but configured through git means it supports all git features outputting code. Highly configurable theming and output options e.g. colors, line number styles. Cross platform and OS packages for multiple systems.

What we like: Runs the commands from your Procfile or Docker Compose config e.g. running separate commands to launch your project’s UI and API. Aggregates logs into a single, colorized terminal output. Local web GUI allows log toggle, search & filtering, manage spawned processes and other resources e.g. Docker storage. CLI can control processes, query logs and daemonize.

What we like: Local evaluation of feature toggles avoids network latency. SDKs for all major languages. Proxy module means it can work even for single page apps. Support for gradual rollout and user segmentation strategies e.g. by user profile fields. Tech debt dashboard tracks use of feature flags and warns if they are unused.

What we like: Highlights dependencies and related code structure. Code maps auto-update with each commit - map diffs posted into GitHub PRs. Can build step-by-step tours for onboarding new devs into the codebase. Auto heat maps by latest activity, creation date or commit count.

What we like: Uses terminal theme colors. Layout makes it easy to read. Tree option shows parent and child processes. Can look into Docker to reveal container name & commands. Watch mode like top. Columns can be configured at run time or in a config file. Can show ports processes are listening on. Cross-platform support.

What we like: Ranking algorithm means it usually guesses which path you mean so you can navigate common long paths without typing them all out. Multi-platform options for installing. Includes an fzf-powered interactive mode. Integrations available for Emacs, Ranger, Neovim. Zsh autocomplete available.

What we like: Auto connects to Brave, Firefox, Chrome, terminal, Android, Edge or acts as a generic proxy. Inspect all HTTP requests. Create rules (match on regex, URL, host, JSON, headers), intercept and rewrite - pause requests to manually edit them, time out, transform, forward to different hosts or return fixed responses. Open source.

What we like: Quickly examine or search the full contents of any container - files, layers, Dockerfile. Visual diff of file system, image metadata, and Dockerfile between container versions makes it easy to see what has changed. Examine popular public images and connect private registries (Docker Hub, GCR, AWS ECR).

What we like: Methods for enforcement at request and field level. Relations allow hierarchical access control. Data filtering converts policy expressions into DB query plans to efficiently retrieve only the data that matches the filter. Generic policy language is evaluated locally by language-SDKs (NodeJS, Java, Python, Ruby, Go, Rust).

What we like: Helps validate files, APIs and configs e.g. k8s files. Definitions start broad e.g. types then narrow down e.g. values, so it is easy to get started, but still supports specific validations. Language is a JSON superset. Supports comments (unlike JSON!). Can extract existing definitions from Go and Protobufs.

What we like: Stores access credentials in native OS storage e.g. Windows Credential Vault, macOS Keychain. Easy to switch between credentials e.g. AWS IAM, Azure User. Session credentials are temporary, minimizing risk of leaks and making them easy to rotate. Open source.

What we like: Supports all API protocols (REST, GraphQL, TCP, gRPC). Handles API versioning and deprecation. Hot-reload without dropping requests. Minimal dependencies (Redis for distributed rate limits and tokens). Drop-in products for developer portal + docs, analytics, social auth, management dashboard. Open source or cloud options.

What we like: Catches common issues which can either be fixed as part of a PR and/or blocked by CI. Can open “Autofix” PRs for code issues as well as linting errors. Examines docs and code coverage and reports metrics for both. Image badges for readme files. Can configure analysis via a config file in the repo or via the UI. Self-hosted version available.

What we like: Abstracts auth and storage so you can use P2P decentralized tech like IPFS without worrying about the underlying protocol. Web Native File System works across platforms and has a POSIX-style interface. Supports storage/execution of WebAssembly modules which are then available on every platform. Open source.

What we like: Web demo allows you to query any public repo (+ GitHub issues), or download the CLI. Can do complex queries like commits by email domain, most frequently changed files, filter by branch. Supports querying GitHub API e.g. query stars, repo language stats, issues/PRs. Outputs as an ASCII table, JSON, CSV or SQLite file for other tools to query the results.

What we like: Code structure search on syntax e.g. function arguments, multi-line blocks, JSON structures. Can scope to repos (public / private), commit diffs/dates, languages. Option for self-hosted indexer for private code. Browser & IDE extensions for quick search and overlay on top of existing tools e.g. GitHub/GitLab PRs. CLI or web UI (with dark mode).

What we like: Build & execute HTTP, GraphQL & WebSocket requests. Syntax highlighted response parsing. Generate code to execute requests via curl, Go, Python, and other languages. Save config to local storage or GitHub Gist. Also available as a Chrome or Firefox extension. CLI in beta. Open source.

What we like: Quickly build interfaces to existing databases. Proxies queries to the data source so results are not stored. Easy form construction with validation and data binding. Can use JS to write data transformations (both read and write). If the GUI concepts are too restrictive, you can always fall back to JS to customize widgets. Open source so you can host it all inside your own network.

What we like: Supports staging / non-staging environments. Datasources can be databases like MySQL and Postgres or APIs like Stripe, S3 or GraphQL. Can query all sources with SQL even if they aren’t databases. Everything is a JS object you can manipulate. You can build your own custom React components. Can configure your own Redis/Memcached cache.

What we like: Easy to see security status for everything. Scans full dependency tree revealing your actual security posture e.g. vulns in dependency dependencies. Relative severity scoring helps understand how relevant issues are. Inspects containers & OS packages as well as code. Separates dev dependencies from prod. Multiple options for fixes e.g. via CLI, not just PRs.

What we like: Assessment criteria are objective, consistent and documented so OSS projects can start to adopt them. Makes it easy to assess the security posture of the projects you rely on. CLI output is clear why a check fails. Can scan a GitHub repo or infer it from npm, pypi or rubygem package names. JSON or CSV output means results can be scripted.

What we like: Components to easily add live presence (live cursors, chat and reactions). Abstracts away the backend implementation challenges - networking, performance, presence detection, multi-browser support. Vendored as React / Node packages. Auth hooks to validate user permissions. Examples for raw JS, Next.js, Nuxt.js and React + Firebase.

What we like: SDKs for React, JS, iOS and Android to build video / audio without needing to understand WebRTC. Selective Forwarding Unit server makes it easy to scale from P2P to supporting large numbers of participants. Server scales horizontally using Redis as the backend. Automatically supports different connection types (UDP, TCP, TURN) and simulcasting.

What we like: Multiple browser panes side-by-side to test various sizes. Inspect element works across panes simultaneously. Scroll sync helps comparison. Built on Chrome so devtools available. Shows Web Vitals scores. Can trigger media features e.g. prefers-color-scheme, reduced-motion. Debug tools like a11y, CSS injection, disable images, mobile reachability.

What we like: Built for JS applications to allow read/write to properties whilst avoiding conflicts. Maintains a history of all changes. Network-agnostic but includes a sync protocol for send/receive messages. Custom types for conflict free counters, collaborative text editing and tables. Follows the idea of functional reactive programming.

What we like: Quick start a P2P encrypted call + screen sharing session. Quality settings go up to 5k to make code crisp and easy to read, unlike generic conferencing services. Easy to take control to type, send through keyboard shortcuts, highlight areas of the screen. Live call debug info to see any connection problems. The “ship it” stamp effect is fun.

What we like: Autocomplete is accurate - speeds up work on a line-by-line basis, just like GMail/Google Docs. Understands file context - imports, variable names, etc. Using comments to describe what you want to do then reviewing suggestions is like doing a web search. Time saver for simple, common, but annoying tasks e.g. regexes, test skeletons.

What we like: Single command to get your code into production. Can track Git repos to auto-deploy. Integrates with AWS, Azure, Google to upload artifacts, configure LBs, DNS, env vars, etc. Stream logs and execute remote commands. Preview URLs for staging. Web dashboard summarizes deploy status. Extensible hooks via plugins.

What we like: Built-in tabs, panes, sessions, resizing, scrollback. Shows (customizable) keybindings to help discovery. “New pane” algorithmically placed in the most optimized position (or use manual splits). Can configure layouts in yaml then auto start them. Single compiled binary. Has a built-in file manager (a clone of ranger). WASM-based plugin system.

What we like: Really simple way to execute HTTP commands but can also send more complex requests e.g. headers, file uploads, cookies, JSON. Can write commands in plain text, JS, or define variables in templates. Prettified and syntax-highlighted response parsing. Can save to local browser storage (GitHub and others on roadmap). Open source codebase.

What we like: Single compiled binary. No bootstrap requirements - supports many platforms. Can query password manager for secrets and supports encrypted files. Configs can be templated for differences across environments. Can run scripts, including run-once (ideal for cloud IDEs or ephemeral environments). File edit flow similar to git (which is used for versioning).

What we like: Lookup IP details such as ASN, location, hostname, abuse contact, tor/VPN/hosting IP categorization. Cross-platform binaries. Colored output. Bulk summarize IPs from a file (or piped in). Bash, zsh, fish auto-completion. SDKs available for major languages.

What we like: Focus on high-performance repo parsing using async means the UI is responsive, low memory and low CPU even for the largest of repos. Keyboard control of common tasks e.g. stash, stage, diff review and commit with keybindings highlighted for newer users (or when you forget). Adopts terminal color scheme. Cross-platform packages (Arch, Fedora, Homebrew, Chocolatey, Nix).

What we like: Real-time change indicators show where others have made changes to files but not yet committed. Preview live diffs and get warnings about conflicts from other collaborators. Privacy option to stop sharing when required. Built-in video calls and codesharing which works across IDEs - VS Code, JetBrains, Android Studio.

What we like: Terminal-based signup/demo. Template / version control production commands - scripts, databases, containers, cloud consoles. CLI or Slack Bot to trigger them without direct prod access. Auth/approval flows before commands execute. Optional self-hosted runner with secrets stored in your own secrets storage. Auto-redaction of sensitive logs. Bastion SSH support.

What we like: Solves the hassle of configuring SSL for local dev endpoints by configuring and managing a root CA. Means you don’t need to leave testing SSL to staging (or prod!) or store real certs locally. Allows you to generate certs for localhost. Cross platform + support for browser specific root stores.

What we like: Packages ranked based on various criteria such as documentation, performance, popularity. Categories for common use cases to help find most used packages. Analyze dependencies and project activity e.g. release cadence, commit frequency.

What we like: gitmoji helps identify commits at a glance. CLI sets up a Git commit hook to trigger the interactive CLI to pick a gitmoji for the commit. Text search to find right emoji based on commit purpose. Can be configured to use Conventional Commits scopes.

What we like: Can do arithmetic, import modules, use data types, loops, etc, because everything it receives is interpreted with Python. Tab completion based on man-pages. Community extensions e.g. Powerline, written in Python. Cross-platform.

What we like: Access AJAX, CSS Transitions, WebSockets and SSEs directly in HTML. Any HTML element can issue AJAX requests. Implements the principle of “locality of behavior” so it’s easier to understand what code is doing. Small (10k min gz), no dependencies.

What we like: Open source, runs locally and/or in CI/CD. No DSL - write rules in the language you use and alongside the code they check. Plugins for as-you-code analysis in Vim, VS Code, IntelliJ. Lots of community rules for common languages and frameworks (Django, Flask, Java, Rails). Integrates with CI and can add comments to PRs. Cloud web UI is optional.

What we like: InfluxDB-compatible ingestion. Postgres-compatible wire API (allows querying with Grafana). Handles out of order inserts in a configurable way even though it uses an append column-based storage model. Official Docker image and Helm chart for dev/prod deploys. ANSI SQL with additional time functions. No GC.

What we like: Search shell history with CLI or interactive TUI (ctrl+r). Query by date, current directory, string terms. Encrypted sync across machines with log of exit code, session, command. Fun stats e.g. “most used command”. Option to run your own sync server.

What we like: Google Docs-style real-time sharing / editing. Detects dependencies, prompts for pip install and updates requirements.txt. Running the Jupyter environment in the cloud saves hassle installing kernels locally. Integrates with git. Public links. Supports Python & R.

What we like: No dependencies. No build step. Very small (~400 LoC vDOM, ~100 LoC state management, ~230 LoC HTML helpers). Works with async components. Web tutorial does a good job explaining how it works (built using itself).

What we like: Saves building your own queuing system - acts as a proxy to store and forward webhooks. Set up throttling and retry rules. Mirror inbound webhooks to multiple destinations, including a local CLI for testing. Alerts on failures - allows you to search & retry failures so you don’t lose any data.

What we like: Local simulation of the GitHub Actions environment using Docker. Much faster than commit/push for testing changes. Supports environment variables and secrets. Can trigger specific events e.g. pull request, push, and jobs within workflows (including skipping steps).

What we like: Packages for all platforms (+ Nix, AUR, musl). Uses relaxed SQL to support fields e.g. size, path; operators e.g. AND, gte, like; date queries e.g. created, modified; filename glob and regex. Can use .gitignore and search MP3, MIME and other file attributes. Output in CSV, JSON, HTML.

What we like: Write a script to make a change to a single Git repo, then apply that change across multiple (specified in a list, or entire GitHub Org). Executes in parallel. Can open GitHub PRs with changes. Lots of use cases for otherwise tedious work e.g. name changes, updating dependencies, mass config changes.

What we like: Drop-in replacement for Redis. Claims x5 speed boost from multi-threading. Adds some extra features like backup to S3 and active replication. Potentially reduces operational complexity by shifting scaling to CPU cores and network throughput rather than requiring clustering.

What we like: Easily build HTTP requests with custom params, auth (basic, bearer, OAuth), headers and body (text, JSON, XML, form, GraphQL). Parses and syntax highlights response, headers and cookies. Can create automated tests with conditions such as response time, status codes, headers, etc.

What we like: Create a read/write REST API to start building against before your backend is ready. Supports all HTTP verbs. Lots of default field types with sample data e.g. location, emails, avatars, credit cards.

What we like: Makes it easy to burst parallelizable commands into Lambda. Uses Go template language for managing input and output. Supports Docker wrappers to bootstrap environments. Includes a drop-in GCC/clang replacement for outsourcing compilation.

What we like: Single binary (C++) runs natively on Linux and macOS. Tunable ranking for relevancy score tie-breaks. Sort at query-time without additional indexes. Scoped API keys. InstantSearch.js adapter. REST API with clients for JS, PHP, Python, Ruby. Open source + cloud option.

What we like: Offering webhooks is actually more complex than you'd expect. Diahook deals with signing requests, queueing, retries, reliability, auth, E2E encryption, rate limiting, logs and debugging.

What we like: Deals with the underlying infrastructure for reliable task execution: state management, retries, scaling, fault tolerance. Avoid building and running your own timers / queues - just write the function business logic. Open source server you can run yourself, or use their cloud option (in private beta).

What we like: Intercepts all XMLHttpRequest and fetch requests so no code changes required (one additional import). Includes in-memory database for persistence tests. Can simulate slow responses or errors. Built-in ORM handles data relationships, output formatting, serialization.

What we like: Forces you to think about what you are going to work on in advance - writing out a plan probably helps improve your thinking, and also creates better commit messages. If you think of something you need to switch to, you can create a plan whilst it’s still top-of-mind, then come back to it later.

What we like: Quickly create step function APIs from lots of pre-built integrations. Cron support. Connect to external data sources and manipulate data. Write real Python, JS, Java, shell script, GraphQL, HTML, and SQL (including using packaged dependencies) as separate steps. Configurable editor e.g. use vim keybindings, tabs vs spaces, etc.

What we like: Fast execution of steps due to caching. Can retry builds from specific steps and live-debug in a terminal which makes setting up pipelines easier. Can switch between UI or YAML config. Commenting/sharing helps team collaboration. UI has useful features, such as env var autocompletion.

What we like: Open source & self hosted: you probably don't want to build all your own user management (signup, login, MFA, FIDO2, etc) but do care about control and ownership. Runs as a compact, single Go binary. JSON Schema data model. Headless; example UI and API SDKs for Python, PHP, Node, Go, Java, Ruby. Scale horizontally.

What we like: Autocomplete and flag suggestions. Commands such as release or sync combine several commands in one to speed up common tasks. Branch autocomplete for checkout. GitHub PR integration. Support for themes. Open source & cross platform.

What we like: Captures screenshare and click journey with associated metadata like console and network logs. Local-first; uploadable for sharing (private or public). Quick submit to JIRA, Linear, Trello, GitHub

What we like: Runs existing build steps inside a container using your existing CI system (Jenkins, CircleCI, GitHub Actions, etc). This makes builds reproducible locally so they run the same on your laptop as in remote CI. Steps can be parallelized. Dependency caching locally and across repos.

What we like: Single API to launch and script Chromium, Firefox and WebKit. Emulate devices for testing responsiveness. Auto-wait API avoids hard coding timeouts. Extract screenshots, video and debug info. Library for JS, TypeScript, Python, C#, Java. Works on Windows, macOS, Linux.

What we like: Build OpenAPI (v2 Swagger or v3) compliant APIs with auto-generated docs, example code, and mocking. Write docs in Markdown. Save everything (and load existing APIs) from Git. Offline/local dev support with desktop API studio app.

What we like: Search cloud and local documents. Clipboard history. Manage GitHub PRs, JIRA issues, join Zoom calls, schedule calendar blocks. API and scripting to create your own commands. Tiling window management. Connects directly to remote services to avoid privacy issues.

What we like: Autocomplete and syntax highlighted output. Support for Postgres, MySQL, SQLite, MSSQL, Redis, AWS Athena. History, search, vi/Emacs keybindings, saved queries. Open source & cross-platform.

What we like: Scans Terraform, k8s, and Helm configs for security and compliance. Supports AWS, Azure, GCP, Kubernetes, GitHub and has lots of sensible policy defaults which can be extended using the Open Policy Agent Rego language. Can be run in CI/CD.

What we like: .gitpod.yml file in the repo describes the full dev environment so it's version controlled and always up to date. GitPod pre-builds after every commit so the environment is ready when you activate it. VS Code in the browser means you can develop anywhere on any machine. Easily switch workspaces e.g. to review a pull request without disrupting your current environment. Self-hosted version so you can run it all yourself (some features limited to paid license).

What we like: Makes it easy to switch language runtime versions without messing up the system install (if any). Lots of plugins so it supports pretty much every language. Configs can be defined in a per-project file so it can auto switch based on current working directory. Means you can forget about language specific virtual environments because asdf manages them for you. Has an official GitHub Action.

What we like: An easy way for developers to run a standardized suite of black box tests. Spiders and auto-discovers endpoints so there is almost zero config. Runs inside a container so it can be run anywhere. Web UI highlights and prioritizes all detected vulnerabilities. Can easily be run locally against any local or remote endpoint. Built on top of open source OWASP ZAP. Good quality documentation. Integrations into CI/CD e.g. GitHub Actions, GitLab, CircleCI.

What we like: Automates deployment of Prometheus, Cortex, and Loki and configures them to store data in your own S3 or GCS buckets. This means you keep control of the data and the price of storage from your existing cloud provider. Supports multiple tenants e.g. prod vs dev, and deals with scaling them. Existing Prometheus instances can be configured to send data to Opstrace.

What we like: The first thing you notice is running `ls` outputs a structured table. All output is actually data, so it is like interacting with a spreadsheet. Nushell applies the Unix philosophy of piping commands but allows for commands like `ls | where size > 1kb`. Supports parsing data like CSV and JSON. You can script your own commands. Cross platform.

What we like: Open source end-to-end encryption based on libsodium. SDKs for JS, Python, Java, Kotlin, C/C++, Rust. Handles sync and user sharing e.g. users collaborating on an encrypted doc. Has specialist types for calendars, tasks, and Markdown notes. Supported by a foundation and a European Commission program.

What we like: Integrates with CI (GitHub, GitLab, CircleCI, Bitbucket) to provide cost diffs for pull requests. Supports AWS and Google Cloud.

What we like: Deploy a full AWS stack in a local Docker container. Avoid paying for AWS environments for test/dev. Supports key AWS services like DynamoDB, EC2, Kinesis, Lambda, Route53, SNS, SQS. Allows you to inject errors.

What we like: rsync.net is a Unix (ZFS) filesystem over SSH but also supports commands like borg, git, rsync, s3cmd, and now rclone. rclone is a separate open source project that exposes many cloud accounts as filesystems e.g. Google Photos, Dropbox, Azure Blob storage. rsync.net connects directly so you can copy from one to the other without downloading/uploading.

What we like: The whole idea behind using the command line is to make things faster, usually using the keyboard. This helps with that goal by improving select, copy and paste inside tmux. It works everywhere, even in SSH sessions. Works with clipboards on Linux, macOS, and Windows.

What we like: Managing lots of individual Lambdas across environments and regions is a pain because of how long it takes to package and deploy, especially with AWS rate limits. Seed hooks into Git and speeds things up by deploying concurrently. Supports Serverless Framework, caching dependencies, and incremental deploys. Built-in Lambda monitoring for errors. Also supports AWS CDK.

What we like: Decentralized filesystems allow access to content without relying on a specific host. This makes them resistent to censorship (or outages, deletion, etc). IPFS can be a pain to run, or you have to use a gateway service. Built-in browser support means users don't have to care, just like with HTTP. Brave is based on Chromium (but better privacy than Chrome) so most sites work fine.