Console
Devtool reviews
Each week Console reviews the best tools for developers.
✦ Disclosure: All reviews are editorially independent and partners must meet our selection criteria.
Latest Tools(100)
What we like: Define your schema in TypeScript with no build/generate step required. SQL-like interface with the option to call SQL directly and/or use prepared statements. Includes migration functionality with supporting CLI and a local GUI for exploring the database. Zero dependencies and supports edge/serverless functions.
What we don't like: No support for DynamoDB, CockroachDB, MS SQL.
What we like: Makes it easy to build product tours, onboarding, contextual help, and highlights. Can be themed via CSS and implements keyboard shortcuts. Everything configured and driven by code e.g. loading data before triggering a tour or starting a tour from a later step. Open source.
What we don't like: Based around page elements, popovers and highlighting which is great for most tours, but may be too limited for anything more advanced.
What we like: Generates a CHANGELOG, creates the GitHub release, and bumps versions in language specific files e.g. package.json, Cargo.toml, setup.py, etc. Supports a range of languages. Parses conventional commits so understands version bumps for breaking changes. Manages Git tags.
What we don't like: Requires conventional commit formats and does not handle publishing releases to package managers.
What we like: Standalone CLI for managing database migrations. Maintains a “current state” SQL file so you can always provision the database and diff changes. Migrations are specified in plain SQL with up and down states to support rollbacks. Runs migrations inside transactions. Single binary & can also be embedded in code (Go).
What we don't like: Framework agnostic, but may not play well if you do use a framework like Prisma and want to manage migrations for its schema across other languages. Not sure if that’s a limitation of DBMate or Prisma, though!
What we like: Linter CLI for enforcing a specific writing style. It’s not prescriptive - there are lots of open styles used by the likes of Microsoft, Datadog, Spotify, Grafana, which you can use. Customize the configuration to define your own rules. Works on formats like Markdown, HTML, AsciiDoc, code comments. Various editor plugins e.g. VS Code, Obsidian, Vim.
What we don't like: It’s designed for text files - great if that’s where you’re writing, such as for technical documentation, but there’s no support for other common editors like Google Docs or Word.
What we like: Opinionated methodology to help combine changes into a release, particularly when they span multiple packages. Changesets then get combined into a changelog and a version bump, which helps coordinate a package release. Can be integrated into CI to automate releases. Includes a GitHub Action and build/publish support for NPM.
What we don't like: Best for NPM / JS monorepos. It will work with other package types, but only if there’s a package.json.
What we like: Uses hardware acceleration for large string manipulation. Supports length, indexing, slicing, count, substring matching, and split. Works with strings and files. File supports memory maps without loading a copy into RAM and becomes immutable so can be shared across Python processes. Performance up to 12 GB/s vs native 14 MB/s.
What we don't like: Bindings for C and Python only. Rust & JS planned.
What we like: Single configuration for domains with support for 35+ providers such as AWS Route53, Bind, Cloudflare, DNSimple. Has migration scripts to bring in existing records. Makes it easy to store in Git and push changes via CI/CD. Supports notifications e.g. Slack, when changes are made. The config is JS so you can use JS language features e.g. loops.
What we don't like: The DSL is JS rather than TypeScript, however some editors e.g. VS Code, support autocomplete and type checking.
What we like: Windows app providing lots of useful common tools in a single (offline) app. Includes convertors e.g. JSON to YAML; encode/decode e.g. URL, base64; generators e.g. hashes, lorem ipsum; graphics e.g. format convertor. Supports compact mode and pinning to the start menu. Open source.
What we don't like: Windows only.
What we like: Based around React components which can be customized with CSS variables, inline CSS or Tailwind. Build custom flows with social signin, SSO, organizations, and MFA. Everything is available as an API for integration into backend code (there’s also a Go SDK). Has helpers for e2e testing using Cypress.
What we don't like: Backend SDKs are only available for Go, Ruby, and JS - you’ll need to use the API for everything else.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Setup and connect environments via a private network. Require multi-step authentication with audit logging to gain access e.g. your SSO + customer approval to log into their network. Local client for viewing networks and managing connections. Create services for headless access, use DoH on the network, connect to serverless environments e.g. Fargate.
What we don't like: Doesn’t support connecting directly to managed services e.g. databases like RDS. UI has no dark mode.
What we like: CLI for transpiling, transforming, bundling and minimizing CSS. Built for performance (in Rust). Can help with using current CSS features even with older browsers by using vendor prefixes and conversion to older syntax based on desired browser targets. Works with Parcel, Deno, webpack & vite. Can also be used as a library in JS or Rust.
What we don't like: Missing full support for CSS modules.
What we like: Define your infra in TS, Python, Go, C# or YAML. Pulumi provides managed templates for which implement “best practices” e.g. security groups and IAM roles which makes it easy to deploy common services like ECS or Lambda. You can import Terraform modules. End to end CI & CD for infra and code e.g. build, upload, deploy a Docker image. Docs chat AI gives helpful code examples.
What we don't like: Some of the docs aren’t up to date on the latest release. Doesn’t support more complex code deployment models e.g. green/blue with easy (non Gitops) rollbacks.
What we like: Fast and easy to configure. Sets up HTTPS for public domains automatically using Let’s Encrypt. Can also be a reverse proxy. Configuration via a simple text file and/or via a JSON API so it can be managed programmatically. Has OpenTelemetry & Prometheus integrations. Open source and provided as a static binary for every platform (written in Go).
What we don't like: Requires a bit more work to get local HTTPS working, but that’s just due to how the custom root CA needs to be explicitly installed and trusted.
What we like: Makes it quick to search through the node_modules directory for specific packages. Can find all instances of a given package, including where it's a dependency of another package. Shows the version info and how that relates to the current latest release. Helps find all your sub-dependencies. Supports fuzzy search.
What we don't like: Missing full support for pnpm due to how pnpm structures node_modules with links.
What we like: Easily set up various auth methods - social login, passwordless, SAML, SMS. Integrations into frameworks like Next.js (including app router), React, Go, Python, iOS. Supports RBAC. Includes audit logs and webhooks for events. Dark mode. Can be cloud hosted, but is also open source so you can run it yourself.
What we don't like: Customization is through CSS injected into their UI - would be good to see these as more flexible React components.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Manages language toolchains and integrates with the native package managers throughout your monorepo. Provides a single CLI for running tasks across languages and packages. Supports multiple languages e.g. you can trigger Node and Rust tests with one command. Remote caching and chained pipelines to speed up builds.
What we don't like: Works with most languages, but toolchain integration and integration into package manifests and lock files only currently supported in Node, Deno and Rust.
What we like: Point it at your protobuf files and you can easily interact with gRPC endpoints. Can also detect the services based on reflection, if supported by the endpoint. Supports TLS and plaintext (useful for development), plus streaming methods. Can be pipelined with tools like jq because it works with JSON request bodies that it translates to gRPC. Single binary (Golang) and open source.
What we don't like: Only supports JSON inputs. No release for a year even though development has happened on main.
What we like: Easy to self-host in a single container backed by SQLite, but can scale horizontally by connecting MySQL, Postgres, etc + load balancer. Official client libraries for a range of languages. Can split the audience into segments for conditional flagging. Supports gradual rollouts as a %.
What we don't like: Docs are primarily about deploying & running Flipt rather than explaining how to use the core feature flag functionality.
What we like: Works on the assumption that the file you’re looking for is probably higher up the directory tree, so optimizes the index for breadth rather than depth = faster results. Compatible with the find command, but with easier to remember arguments. Has better errors and suggests corrections. Packages available for most OSs.
What we don't like: Built for *nix systems - you could try building it on Windows through WSL.
What we like: Similar to Homebrew on macOS, lets Windows users install apps from the command line. Bypasses permissions and GUI wizards. Manages all dependencies and any extra setup. Has community packages for games, fonts, Java, PHP, databases. Scriptable for automating machine bootstrapping. Easy to write your own packages.
What we don't like: Windows only (obviously). Requires PowerShell to install.
What we like: Well thought through API for sending emails. Official SDKs for Node, PHP, Ruby, Go, Elixir, Python. Works with serverless or edge functions. Delivery logs to debug sending issues. Domain verification with DMARC. Webhooks for delivery events.
What we don't like: No recipient or subscriber management yet - you’ll need a separate system to manage a mailing list, for instance.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Install as a GitHub app to automatically scan your PRs as dependencies change, which are an increasingly common attack vector. Detects various issues such as malware injection, changed package behavior, new authors, data exfiltration, license issues etc. Can also run as a CLI or VS Code extension.
What we don't like: Only supports JS/TS & Python ecosystems. Go in private alpha and other languages on the roadmap.
What we like: Makes it easy to run multiple processes as defined in your Procfile. Uses tmux behind the scenes so you can connect to any of the processes. Direct control of processes to restart specific ones without interrupting the others. Process output is properly captured so it doesn’t break colors.
What we don't like: Obviously assumes you’re using a Procfile, which is perhaps less common with container-driven development these days?
What we like: Easily create tours, checklists, highlight boxes, tips, and onboarding flows. No-code UI to define flows, logic & branches, but there’s also a full JS SDK for customizing components. Supports custom styles, targeting rules, state management, and analytics. Can trigger webhooks when steps are reached.
What we don't like: Limited to frontend onboarding - SDKs are only for JS and React.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Bring third-party code into your repo and keep it up to date. Supports syncing from files, git, downloading and extracting from remote URLs. Pulls in specific revisions and can auto-update when new versions are published. Can be run as part of a build process - commit the config to your repo.
What we don't like: Supports limited sources, but actual packages & dependencies are probably already managed as part of your language toolchain. Requires Python rather than a static binary.
What we like: Acts as a mail server (SMTP or API) for testing emails from your code. Static binary so can easily be run in CI/CD. API allows querying of received emails so you can check they were correctly “sent”. Can persist mail to a SQLite database. Has a web UI to inspect mail e.g. for local development.
What we don't like: Designed for integration testing rather than as a library for unit testing or mocking - which is probably what you want for email tests, but means you need to configure it as a service. Includes Docker images to support this.
What we like: CLI to provision preview environments based on your Docker Compose config. Runs in your own cloud (AWS Lightsail, GCP, Azure). Expose apps to the web or securely access via a tunnel. Run in CI e.g. for E2E tests. Auto configures HTTPs. Supports plugins for responding to events e.g. posting environment URLs to a GitHub PR. Open source.
What we don't like: Tunneling uses the Authorization header, which may break your services if you also rely on it e.g. for auth or WebSockets. Assumes you use Docker Compose.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Super simple k/v store API for JS. Defaults to in-memory with no dependencies, but has adapters for Redis, Mongo, SQLite, Postgres, MySQL. Handles all JSON types (supports custom serialization) with a Promise-based API. Supports TTLs and namespaces. Open source. Plugins for extra functionality e.g. memoize a function.
What we don't like: Limited to set, get, has, delete and clear functions. If you want more sophisticated options e.g. increment or setting fields on a hash, you’ll need to use something else e.g. Redis.
What we like: Integrates with AWS, GCP, and Azure to provide real time cost reporting and analysis. Provides a kubectl plugin to allow querying of cost data. Export pricing data to Prometheus to build into your queries/dashboards. Integrates with k8s to provide allocation by workloads, containers, etc. Override pricing data e.g. for on-prem deploys, or use cloud pricing APIs. Open source.
What we don't like: Requires a complex setup - you already need to be running k8s and Prometheus. There are multiple open GitHub issues related to Azure, so these are worth reviewing if you want to deploy there.
What we like: Ingest data from official SDKs (Node, Go, Rust, Python), integrations (Elastic, Vercel, Lambda, Cloudflare), extensions (tracing for Python, Next.js, Zap), or generic endpoints like syslog. Powerful query language with functions, expressions, field detection. Use this to build dashboards and set alerts. Offers unlimited retention & no sampling.
What we don't like: Field names limited to 200 bytes. There is an option to run it yourself, but this brings an ingest constraint of ~1.5TB/day/vCPU and requires you to run Postgres + object storage e.g. S3.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Deployed as a single (C++) binary - no JVM. No Zookeeper. Use any Kafka library. Comes with a web console out of the box and can be managed via a CLI (which includes tuning features). Built-in schema registry. Prometheus endpoints. Tiered storage to offload to object storage. Run it yourself, in the cloud, or bring your own cloud.
What we don't like: Schema registry functionality is limited to registration - does not do any deep schema validation and docs are limited about how to use it with Kafka SDKs.
What we like: It’s very fast! The focus on performance really shows - launch speed, memory, insertion latency are all best in class. Supports Vim-mode. Every buffer is a CRDT which allows real-time collaboration like Google Docs. Language server built-in - auto detects based on the file. GitHub Copilot and OpenAI are built in (opt-in).
What we don't like: Basic Git support. macOS only. Very minimalistic - it’s still early in development so many of the features you might expect from VS Code or JetBrains are missing. But if you want a simple text editor-like experience with the necessary bits from an IDE, it’s in a good state.
What we like: Can bring in the context of your entire codebase when providing answers. Can generate suggestions based on code smells, performance optimization, adding docstrings or improving variable names. Can explain code, generate release notes, and summarize recent changes. Will also write code for you e.g. unit tests.
What we don't like: Limited to the web, VS Code or JetBrains IDEs.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: It’s fast - launches within ~2 seconds vs Docker Desktop > 10 seconds. Speediness also extends to launching containers - uses Rosetta x86 emulation and modern i/o APIs on macOS to optimize performance. Native UI. Also supports creating Linux VMs with Intel emulation. Very low CPU usage.
What we don't like: Obviously macOS only. Doesn’t fully implement all Docker Desktop features e.g. directly browsing container files is not implemented in the UI.
What we like: Trigger a JS/TS function on a time interval (Vixie Cron syntax) or once on a specific date. Configure max runs, timezone, intervals between executions. Overrun protection. Can query the status (next run, is running, is stopped, etc) and control it (trigger, pause, resume) once initialized. Runs in Node, browser & Bun.
What we don't like: Runs entirely in memory - great to have no dependencies, but does mean there’s no persistence of state (which may not matter for idempotent cron triggers).
What we like: Preview environments for your entire app - frontend, backend, database, and any other containerized service. Spins up new environments on PRs or on-demand. Use for testing, QA, or demos. Access logs and monitoring stats. SSH into the environment for debugging. CLI to create and manage environments.
What we don't like: Only way to configure environments is via Docker Compose, although this does mean the preview environments match your local environment (and hopefully prod, too).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Provides hints for commands before you run them. Understands complex data formats like JSON and tables to allow navigation and highlighting. Built-in scripting support. In-line spell checking and autocomplete. Error handling and debugging built in - use try/catch blocks, descriptive error messages.
What we don't like: Windows is supported, but not fully - recommendation is to run it within WSL.
What we like: Describe task steps in YAML and it executes them. Designed to be very simple, but supports advanced features like including other task files, dependencies, variables, platform specific commands. Doesn’t re-run commands if the output hasn’t changed. Easy to install in CI. Single (Go) binary. Open source.
What we don't like: Reports of high CPU usage if watching large numbers of files e.g. a node_modules directory. This is an optional mode used to watch and rerun tasks if the file changes.
What we like: Instant setup with easy schema-definition and predefined or custom field types - full access to all Postgres types. CSV import & export. Spreadsheet-like UI for searching, filtering, editing rows. Get a connection string for remote access. Query via SQL from within a Retool app. Redundancy & backup handled for you.
What we don't like: Designed for small use cases that don’t require high availability or scalability e.g. internal tools where it’s not a good use of time to manage your own database. Initial quota matches this - 5GB storage (can be increased on request).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Static (Go) binary to search code in the current directory. Default mode is to launch a TUI, but the CLI can also take parameters and output the results. Supports exact matching, fuzzy matching, negations, and regex. Can output in text, JSON, or vimgrep. Understands .gitignore.
What we don't like: No installable packages for Mac (binaries aren’t signed, which means a bit of extra work to pass the macOS security). Designed to just work rather than for maximum performance (but it’s still very fast).
What we like: Generic library which makes it easy to build autocomplete. Keyboard navigation available out of the box. You only need to provide a container for the autocomplete and sources for it to get items from. Sources can be static e.g. links, or dynamic e.g. searching a database. Made by, but does not require, Algolia’s search product.
What we don't like: Designed specifically to solve autocomplete, which may be part of search, but can cover other use cases as well e.g. a command bar. This means it doesn’t provide a library of UI components - you’re in charge of building the UI.
What we like: Create & switch between isolated environments with all dependencies managed for you, powered by Nix. Abstracts away a lot of the hassle of using Nix. Makes it easy to deal with various platforms and CPU architectures. Easily bootstrap identical dev and prod environments. Can containerize any environment
What we don't like: Great if all the packages & dependency versions you need are already available on Nix. If not, Nix has a steep learning curve.
What we like: Easy to store, retrieve, and serve objects. Replication strategy can be defined when storing an object. Efficient for lots of small objects. Supports tiered storage in the cloud. Optionally supports directories, TTLs, mounting FUSE drives. You can use the API to serve objects publicly. Static (Go) binary.
What we don't like: Using it more than a key/value like object store requires a separate component which uses a database to persist metadata - this can be in-memory (but no persistence) or supports various datastores - but is an extra layer to manage.
What we like: Simulate a browser accessing a URL to retrieve screenshots, metadata (Open Graph, Twitter, JSON+LD, oEmbed & HTML), convert to PDF, track speed using Lighthouse. Provided as a managed API with a CLI, but it’s made up of various open source components they maintain so you can always run them yourself.
What we don't like: SDKs are JS-only (React, Vue, JS), so you need to use the API from other languages.
What we like: Generates boilerplate Node.js code for APIs (REST & GraphQL), data models, database, auth, and an admin UI. You own all your code (open source) so can customize or diverge. Changes to the framework are sync’d to your codebase via Git & PRs. Plugins make it easy to add other functions e.g. changing the database or adding Kafka.
What we don't like: Admin UI is not customizable. Only supports Docker-based deployments - other options are on the roadmap.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Lightweight zero-dependency type validation for TypeScript (or JS) in Node or the browser. Gives you the power of types at runtime, not just when writing code e.g. checking responses from APIs or from user inputs. Supports complex types including datetimes, IP addresses, objects, functions, etc. Large ecosystem of uses e.g. JSON to Zod, Zod to OpenAPI.
What we don't like: The docs assume you know why you would want to use this, which isn’t completely clear until you experience the benefits.
What we like: Write functions in Python, TS, Go, Bash, or a Docker image and have them executed based on triggers (schedules, via a UI, webhooks, CLI, Slack). Supports step function flows with branching, loops, and error handling. Web IDE, local dev CLI, secrets, state & dependency management. Cloud or self-hosted.
What we don't like: Limited ability to scale past 100 parallel workers. Has a higher cold start latency than other serverless worker platforms e.g. AWS Lambda.
What we like: Provides user signup, login, and role-based authorization flows. Supports social logins, SSO, SAML, multi-tenancy & passwordless login methods. SDKs for most languages & tech stacks, with REST APIs for everything else. Can integrate with API gateways like Kong and AWS API Gateway. Can be self-hosted or cloud hosted.
What we don't like: WebAuthn and passkeys are only available in more expensive plans. Default UI looks a bit dated, so you will want to customize it.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Send things into the pastebin via SSH and get a shareable web URL. No signup required - uses your SSH key. Viewer supports syntax highlighting and markdown parsing. SSH in for a full terminal UI to manage snippets. Each snippet can be set to private with an expiring URL. Can also be self hosted.
What we don't like: Can’t search the snippets once they’re uploaded.
What we like: Write your docs using MDX and React and store them in Git. Layers a nicely designed web UI with dark mode, search & SEO optimization on top. Supports a range of common components like code, callouts, cards, tables, snippets. Includes API documentation from specs like OpenAPI. Has a local dev CLI.
What we don't like: Limited customization options - makes everyone’s docs look the same.
What we like: Build & deploy models from Jupyter notebooks. Provides an inference endpoint accessible via a REST JSON API and from within data warehouses e.g. from SQL, Redshift, or Snowflake. Supports custom environments, packages, tests. Can also run training jobs from a notebook or from Git. Includes logs, monitoring & version control.
What we don't like: Everything is based around Python & Notebooks - this is the standard ML stack, but worth being aware of if you’re using something else.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Use React & components to build interactive command line interfaces. Built-in components for text, colors, flex boxes, borders, hooks, working with stdin and stderr. Supports CSS-like props, testing and all features of React e.g. Devtools. Various open source components e.g. progress bar, table, form.
What we don't like: There’s a significant productivity gain from using React across web, terminal, mobile, etc, but purists might argue CLIs should be built in a more appropriate language like Go or Rust.
What we like: Save web pages to a single HTML file with all assets embedded - means you can load sites offline (or share them). Options to exclude specific assets e.g. videos or audio. Chrome extension is also available. Written in Rust, so is available as a static binary with packages for all major OSs. Open source.
What we don't like: Has no JS engine, so some sites may be broken or not work at all. You can pipe it through a headless Chromium to act as a pre-processor though.
What we like: Easy to run locally in Docker (1 command to get running). SDKs for Node, Go, Python, .NET, Java to produce and consume messages. Also has a REST API. Supports storage in memory, on disk, and remote e.g. S3. Native cluster mode for redundancy. Built-in web GUI for management.
What we don't like: Common queue protocols (AMQP, MQTT) are on the roadmap. Clustering requires k8s.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Single binary CLI which triggers a notification when the process completes. Prefix the command with noti or attach to an already running process. Local notifications by default, but also supports services like Slack, Telegram, Twilio, or speech. Works on macOS, Windows, and Linux. Open source.
What we don't like: Packages only for macOS (Homebrew) - Windows and Linux need to download the binary. No official binaries for ARM.
What we like: Intercepts remote APIs via a proxy, storing the responses so they can then be simulated. Modify the API behavior locally e.g. mocking responses for testing. Supports sequenced requests and state across requests. Introduce chaos e.g. latency or status code randomization. Static binary. Open source.
What we don't like: Getting started docs are unclear. Native language bindings only for Python and Java, but you don’t really need them (they just make a few things easier, like HTTPS).
What we like: Build complex workflows with triggers from third-party apps (AWS, forms, SaaS, APIs, etc), webhooks, cron, email, and others. Process data and create conditional branching with filters and loops. Take actions with the results e.g. send to Slack, create calendar invites, trigger other functions. Drag & drop UI and write JS code. Cloud or self-hosted.
What we don't like: Cloud-hosted version requires a credit card for free trial signup. Cloud instances don’t auto-update to newer versions.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Provides an orchestration layer and web UI for installing and managing self-hosted services. Provision databases and common apps like Ghost, MinIO & Plausible Analytics. Includes pre-packaged setup for common frameworks (NextJS, Deno, Laravel) and languages (PHP, Python, Rust). Can also run generic Docker containers. Open source.
What we don't like: Runs on a single server, which is great for self-hosting non-critical apps, but you then have to deal with server admin, updates, and scaling it yourself.
What we like: API-compatible with both Redis and Memcached, but with performance and scalability improvements. Benchmarks ~1ms P99 latency. Supports Redis and HTTP protocols. Includes an HTTP console & Prometheus metrics endpoint. Scales up to 1TB memory per instance and shards across CPUs. Single binary. Cloud & self-hosted.
What we don't like: Targets Redis 5 API compatibility - other versions in progress.
What we like: Supports classic feature flagging with targeting rules, but also enables experimental A/B testing, gated permissions, and ops rules to handle slow-rollout of backend changes. Separate by prod, staging, dev, environments. Feature opt-in allows users to manage their own involvement. Has both client and server-side SDKs.
What we don't like: Dark mode is available, but it’s hidden behind a beta feature flag! No Rust SDK.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Free & open source library of UI components including form fields, navigation, data display, and layouts. Looks good (including auto-dark mode) out of the box. Fully customizable on each component and/or through global themes. Includes accessibility features. Extensive docs and examples.
What we don't like: Not yet at v1, but approaching stability. Missing some components you might expect e.g. full app containers and certain UI containers.
What we like: Nothing to install - just curl the URL e.g. curl cht.sh/ls to get the cheat sheet for the ls command. Can also be queried by appending a search term after. Also covers programming languages & databases e.g. ask how to open a file with Golang with curl cht.sh/python/open+file
What we don't like: There is a locally installable client, but it requires Python 2 and doesn’t install on Apple Silicon systems. Better to stick with the web client.
What we like: Developer focused log-style entry note format makes it quick to add time stamped notes as you’re working on things. Keyboard optimized, with optional vim keybindings. Tiny mode can float on top of all your other windows for easy access to manage notes. Attach code, images or make notes todo items. Use offline or with cloud sync. Markdown formatting.
What we don't like: Notes stored in a database on-disk, but can be exported to JSON. Theme doesn’t switch based on system settings (have to manually toggle dark or light mode).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Toolchain helps manage protobuf APIs. Single library provides full gRPC support, but also allows usage of gRPC compatible HTTP clients for both HTTP1 and HTTP2. Useful where non-HTTP clients don’t yet work, such as in WebAssembly or Edge runtimes. Can generate both client and server SDKs. Drop-in OpenTelemetry.
What we don't like: Docs have no search. Some clients still in beta e.g. Node.
What we like: Combines frontend and backend SDKs to provide end-to-end session replay and error tracing. Backend logging integrations link up to the relevant user session for easier debugging. Records network activity & console logs. Supports data masking for privacy. Open source so can be self-hosted, or use the cloud version.
What we don't like: Can’t track WebSockets. Frontend session tracking has some client overhead (11kb bundle). The UI has no dark mode.
What we like: Generates type-safe and idiomatic SDKs from your API specs for Go, TS, Java, Python & PHP. Can output them to GitHub (individual or monorepos). Output can be customized e.g. adding comments, changing class names, custom HTTP clients. Automates generation in CI and publishing to package managers. Provides API key management & dev portal.
What we don't like: Only supports OpenAPI v3 specs or JSON schema files.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Execute commands and define desired state across many remote machines, containers, or locally. Can install packages & manage config files. Understands groups, roles, multiple environments & typed actions against databases, firewalls, Git, etc. Can integrate with Terraform, WinRM, Docker, Ansible, and others. Extendable with Python.
What we don't like: Use of Python means it doesn’t require an agent, but obviously means it requires the Python runtime environment locally (remote side only requires a shell) and must be configured in Python.
What we like: Create self-hosted remote dev environments locally (Docker) or in the cloud (GCP, AWS, Azure, Digital Ocean, k8s). Connect via VS Code, JetBrains, SSH. Create workspace templates via Terraform. Connect via port forwarding and share URLs using P2P WireGuard or Coder-provided relays. Supports dotfiles & secrets. Browser GUI or CLI.
What we don't like: Common issues with remote dev environments include latency and inability to work offline, but are these just edge cases? Requires some work to get Docker in Docker set up or you could use a full VM instance per workspace.
What we like: Internal tools as code - write scripts, workflows, dashboards, custom UI for internal tasks. UIs are built using React. Connects to resources like databases & APIs. Provides infrastructure for logging, permissions, approvals, notifications, etc. Supports multi-step tasks & scheduling. Supports local development and self-hosting.
What we don't like: Limited language runtime support (TS, JS, Python, Shell, Docker). The UI doesn't support dark mode.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Docs written in Markdown (MDX, with React component support). Built on top of Next.js. Native support for docs concepts like sections, tabs, callout, syntax highlighting. Supports server side generation from remote sources e.g. GitHub star count. Static search. I18n support. Dark mode. Open source.
What we don't like: Design customization is somewhat limited - you need to create a custom theme from scratch if you want to do more than minor tweaks.
What we like: Supports load testing and functional (assert) testing of APIs, message brokers, ecommerce systems, etc. Supports HTTP, WebSockets, Socket.io, HLS, file uploads, and other protocols via plugins. Reports p50, p95, p99, min and max. CI/CD runners to conduct continuous testing. Test scenarios written in code. Open source + cloud platform for distributed tests.
What we don't like: Can integrate with Playwright for headless browser testing, but this is experimental and the primary use case is backend testing.
What we like: Aggregates observability data from multiple sources (CloudWatch, Prometheus, Datadog, Grafana, etc) to calculate Service Level Objectives. Normalized data across sources - powerful query language for accessing the right data. Can be configured in code (YAML, Terraform, OpenSLO standard) or via the UI. Visual service health map dashboard view.
What we don't like: UI has no native dark mode. Can be complex to set up from scratch (docs provide useful examples and templates for some platforms e.g. k8s).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Self-hosted. Each step is isolated and runs as a container. Define the commands in a config file in your repo with any Docker image as the context. Uses a persistently mounted volume to pass input/output files through the steps. Flexible conditional execution, supports matrix builds, services e.g. databases. Backed by SQLite by default.
What we don't like: Limited pre-built images and plugins - smaller ecosystem than GitHub Actions, for example. Self-hosting is the point, but it does mean you have to run and manage everything yourself.
What we like: Replaces cat. Supports syntax highlighting and has a Git integration showing modifications in the gutter. Includes line numbers (by default, can be disabled) and a pager. Detects non-interactive usage and turns off all the fancy features for full cat compatibility. Single, open source Rust binary with packages for most platforms.
What we don't like: Line numbers get in the way of copy/paste, so you need to remember to launch it with the -p plain flag as needed.
What we like: Create forms visually with simple flows or more complex logic e.g. variables or conditional steps. Integrations for submitting data to databases e.g. Postgres, webhooks, Slack etc. Also supports signup and login flows (Stytch & Firebase). Drop in with JS or use a React component to fully customize the form.
What we don't like: Can be integrated using a React component, but the config is in the cloud not your code. No UI dark mode.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Write event-based background tasks in TypeScript to be triggered by webhooks, custom events, or scheduled. Supports delays, run once, trigger via a separate SDK. Runs as a Node process inside your infra so can connect to private resources. Integrates with Slack, GitHub, Notion. Partly open source.
What we don't like: You run the workflow code yourself, but triggers are via their SaaS platform which can’t (currently) be self-hosted. Workflows can’t yet be run on serverless platforms like Lambda or Vercel.
What we like: Insert into any pipe to provide a visual progress bar. Shows data transfer rate, time taken, percentage complete, and completion ETA. Supports multiple pipes to show progress between them all. Can optionally limit data transfer rate. Supports all major Unix-like OSs. Open source.
What we don't like: Latest release is Sep 2021, but it seems stable so that’s probably not an issue. Some reports of unreliability if backgrounded.
What we like: Simple CLI to compress or decompress. Automatically detects the right algorithm based on the file extension (or file signature) - no need to specify flags. Can decompress multiple files of multiple types in one go. List archive contents (with tree view). Static MUSL (Rust) binary. Open source.
What we don't like: .zip doesn’t support streaming. Doesn’t support adding/removing files from an existing archive.
What we like: Web search and reader UI for programming documentation. Covers lots of languages, frameworks, APIs, products. Keyboard shortcuts and easy search. Search can be scoped and can also be installed into the browser address bar. Offline support & dark mode. Open source.
What we don't like: Works by scraping the web so there’s the potential to be out of date or missing certain docs. You have to enable specific docs to make them available.
What we like: Uses TypeScript and integrates with (abstracts) common headless browsers like Puppeteer & Playwright which makes it easier to keep scripts up to date. Manages queuing, storing results, scaling & proxies. Extensive docs and examples. Open source.
What we don't like: Primarily designed to run locally (or in Docker), but there is a commercial SaaS option for hosting and scaling in the cloud.
What we like: Drop-in JS, Go, Java, or NodeJS SDK for automating anti-fraud, bot detection, account takeover protection, and device verification. Supports client- and/or server- side integrations to protect frontend and backend endpoints. Can connect to third-party services for additional sources of intelligence. Trigger challenge responses like MFA or ID checks.
What we don't like: SDK supports a limited number of backend languages. UI has no dark mode.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Desktop app for diffing text, images, binary, PDFs, and folders. Configurable comparison layout - side-by-side, fluid, in-line, or split view (images). Can ignore whitespace. Can be used as version control diff from the terminal or integrated into your IDE (JetBrains, VS Code, Android Studio, XCode, etc). Send files to ksdiff CLI to launch diff or trigger merges.
What we don't like: macOS only.
What we like: Fast directory browser with a tree explorer that filters files to make it usable within the terminal window. Tree expands as you search and browse so you don’t lose your place. Search doesn’t block - the next keystroke interrupts. Supports commands with live updating views. Preview files. Stage file changes. Single (Rust) binary.
What we don't like: Some keyboard shortcuts don’t work by default on macOS e.g. open in new panel, so you need to rebind them.
What we like: Enables privacy compliant training of ML models on realistic fake data. Connects to your prod database via SQL, transforms (fakes) the data, then trains your model. Provides a report after training to confirm how realistic the trained data was. Supports tabular and event driven models. Export to ipynb. Cloud or self-hosted.
What we don't like: No dark mode. Pretty hefty minimum requirements for self-hosting, but ML training is compute & GPU intensive.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Records production network traffic for reproducing issues later. Stores traffic on disk, S3 (pro version only), Kafka, ElasticSearch, etc. Middleware supports sanitizing sensitive data, emitting metrics, etc. Speed up replay for load testing on real traffic. Transparently captures traffic without affecting it (it’s not a proxy). Open source (some features are paid).
What we don't like: Requires sudo by default, but can run as a non-root user or by forwarding traffic to it. Windows is not officially supported.
What we like: Sticky notes board for your terminal. Works with mouse or keyboard-only. Move, resize both sticky notes and the “board” they’re stuck to. Control over the border and background colors. Notes are saved across sessions and stored in a local JSON file. Open source.
What we don't like: No static binary - installed via pip/Python. Main body entry text field doesn’t expand, which makes editing a bit awkward.
What we like: Link resources in Terraform. Define access rules and workflows in Python. Supports simple approve/deny rules with approvals managed through Slack. But also allows sophisticated rules with routing to teams, auto approval based on who is on call, remove access or de-escalate privileges on events e.g. after going off-call or after a time. Full audit logs.
What we don't like: Requires use of Terraform e.g. no support for AWS CDK. Only supports writing rules in Python.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Counts lines of code very quickly (millions of lines per second) to output stats for lines, code lines, comments, and blanks. Breaks out counts per language. Understands language specific syntax and supports basically every language. Single static (Rust) binary and can be also imported as a library.
What we don't like: No stable release since Jan 2021, but does have recent commit history.
What we like: CLI and shell plugin to auto-switch runtime versions based on per-directory configuration. Reads tool versions file(s) to determine which runtime to install and link to. Supports Bash, Zsh, Fish, Xonsh. Supports asdf plugins. Designed for performance by not using shims (~120ms overhead in asdf) instead updating PATH to directly call runtimes.
What we don't like: No Windows support. Can conflict with direnv.
What we like: Catalog and manage all your internal repos, tools, and services. Allows developers self-service access to provision infrastructure, call APIs, and understand ownership. Useful integrations e.g. CI/CD to view deployments, observability for metrics and SLOs, incident management to escalate on-call issues, etc. Pulls in Markdown docs from the repo automatically.
What we don't like: No dark mode. Service config can be in an opslevel.yml file in each service repo, but actions and checks cannot - they must be configured via the OpsLevel UI.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Single binary outputs Markdown documentation of your whole database (PG, MySQL, MariaDB, SQLite, BigQuery, & others) with one command. Configurable output format (Markdown, DOT, Mermaid, JSON, even Excel). Can diagram relationships. Includes linting function e.g. require comments. Can diff actual vs documented.
What we don't like: It’s a documentation tool, not for migrations or actually creating the tables from scratch from the docs. Limited support for stored procedures and functions.
What we like: Web library for plotting SVG charts, maps, network graphs. Modular and framework-independent - works with React, Angular, Svelte, TS. Easily customizable plots e.g. axis, labels, ticks, and styling using CSS variables. Supports events for mouseover and mouseout. Includes a dark theme for all components.
What we don't like: Legend is a separate component. Offers more control, but then must be configured separately from the graph component.
What we like: Drop-in component for CSV/Excel import rather than building your own - React, Vue, Angular, or JS. Themeable. Can validate fields e.g. email, phone, number. Imported data is sent as JSON via webhook or JS callback. Webhook defaults to batches of 1,000 rows to allow you to process them - waits for a response before continuing.
What we don't like: Need to use the JS callback if you want to keep everything on your own servers.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Single static (Rust) binary that displays a real-time system monitor dashboard in the terminal. Supports widgets for CPU, memory, battery, processes, disk, network. Can expand widgets and navigate using the keyboard or mouse. Configurable via a file, including widget layout. Theme inherits from the terminal or can be customized.
What we don't like: Limited number of widgets. Keybindings not customizable.
What we like: Prevents mistakes by providing types for SQL queries. Understands fields types, joins, subqueries, aliases, and other advanced SQL features. Also supports dialects from databases like Planetscale, D1, AWS, etc. Enables autocomplete in your IDE. Migrations can also be written in TypeScript.
What we don't like: Only works with Postgres, MySQL & SQLite. A third-party project is needed if you want to auto-generate schema definitions.
What we like: ELT-like sync from source(s) to destination(s). Sources can be APIs e.g. AWS or GCP resources, SaaS e.g., HubSpot, PagerDuty, or infra e.g. Terraform, Vercel. Destinations can be databases e.g. Postgres, SQLite, or cloud e.g. S3. Full sync or incremental changes. Typed fields. Option to maintain old records or remove them. Open source.
What we don't like: Concurrency may need to be tweaked to avoid rate limits when syncing resources, but this will increase sync times. Incremental sync only supports local state.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Library to provide structured errors in JS/TS. Set props on errors with typed fields. Wrap, aggregate, normalize errors. Core library provides base functionality which can be extended via plugins. Official plugins for specialist cases: CLI (colorized, pretty print, verbosity levels), HTTP (structured HTTP responses), clean stack traces, and others. Open source.
What we don't like: JS/TS only. Be sure to configure TS to output ES modules, not CommonJS.
What we like: Minimalist CLI designed just to make it easier to navigate directories i.e. a replacement for cd and ls. Fuzzy search makes it navigating through the directory tree very fast. Shortcuts to preview, delete files, and exit with or with navigating to the directory. Prebuilt binaries for Mac, Linux, Windows. Open source.
What we don't like: Requires a workaround to work properly in PowerShell. Have to trigger fuzzy search on every directory change.
What we like: Easily take input from stdin or a specified file then plot a graph in the terminal. Supports bar, line, scatter, box plots, histograms and density plots. Minimal setup needed - assumes first column is x axis and second column is y axis, but this is configurable. Can handle real-time data. Uses default terminal colors. Open source.
What we don't like: Does not support time series. No static binary - installed via Ruby gem.
Interesting Tools by email
Our free weekly newsletter picks out the 2-3 most interesting tools. See the latest email