Console

What we like: Easy APIs for upload, process, embed, stream video. APIs to generate images, clips & previews. Player React component which is themeable, including support for custom domains. Can also handle live streaming. Data APIs for playback and engagement analytics. API for adding subtitles or auto-generating captions.

What we like: Easily spin up a very lightweight GitHub-style UI & Git backend for self-hosting code. Includes YAML-defined pipelines like GitHub Actions which can run multi-step processes e.g. build, test, deploy. Includes a Pull Request UI and proper Git diffs.

What we like: Scans infrastructure as code configs e.g. Terraform, CloudFormation, k8s, Helm, Dockerfile for misconfigurations. Large out of the box library. Can integrate with IDE and CI to help catch issues ideally as you write them, but definitely before they go to prod.

What we like: Import and sync data from many sources (Webhooks, Snowflake, BigQuery, S3, etc). Build metrics and queries you want to create dashboards using GraphQL and REST. Supports time series, leaderboard, and counter outputs. Set tenant IDs for access control. Custom filters & mutations. Open source React components to add to your frontend & display to your users.

What we like: Parses log lines to highlight various data formats e.g. dates, IPs, UUIDs, numbers, HTTP methods, etc. Highlighting rules are configurable. Can watch files in a directory and follow files. Uses less as the pager, so supports keyboard navigation, search, and filtering.

What we like: Zero config search for static sites. Builds the index after the static site build step. No server required. Supports custom sorts, filtering, weighting, and multi-language. Includes a pre-built UI with highlighting of search terms. Indexes HTML by default, but can be customized to add any files e.g. PDFs, JSON, etc.

What we like: Build product (transactional) notifications based on events and advanced workflows. Send messages to the correct channel (email, in-app, SMS, Slack, etc), batching, throttling, avoiding duplicates. Pre-built UI components e.g. feeds (can also be run headless), and native SDKs for most languages. CLI for managing config/workflows locally - (edited in your IDE).

What we like: Explore Redis instances via a desktop GUI. Supports all Redis key types e.g. pub/sub, streams, hash, list, etc. Perform bulk actions. Built-in simple CLI and full workbench for constructing advanced queries / issuing commands. Includes observability, a profiler, and analysis tools for monitoring production clusters. Also supports AWS ElastiCache.

What we like: Designed for file management e.g. sync between directories, copying, uploading, tagging, etc. Connects to multiple sources local, physical disks, remote (Google Drive, Dropbox, S3, SFTP, etc). Themable. Manage files via a CLI. Preview files and edit text in place (even remotely).

What we like: Control access to cloud resources (AWS, GCP, k8s, Postgres, Snowflake) with just in time approvals. Approved entitlements must have an expiry - great to avoid long-lived credentials. Route requests to the right approvers, configured in code. PagerDuty integration for auto-approving when on-call. IAM Audit feature highlights overly permissive policies.

What we like: Terminal UI for exploring JSON files, streams, or piping JSON through pre-processing. Interactive mode for searching JSON and visually expanding the structure. Has Vim compatible keybindings. Includes built-in functions e.g. for fetching data, sorting, counting, etc. Open source & available as a single (Go) binary.

What we like: Extension for Postgres to add columnar table types for analytics workloads. Means you can use existing Postgres clients and queries. Automatic vectorization for aggregate queries. Can copy tables between row and columnar. Built-in cron-like scheduler for regular tasks e.g. analytics queries. Open source. Great, original website theme.

What we like: Automate SDK generation across multiple languages. Also supports generating Terraform providers. Source generation from OpenAPI or JSON Schema specs. Annotations allow deeper customization e.g. supplying docs, how objects are nested, parameters, preventing plan changes etc.

What we like: Ever got stuck with constructing a mental representation of what’s happening with COPY in your Dockerfile? Terminal interface allows exploration of each image layer. Diff changes by layer. Integrate into CI to provide efficiency stats for image builds. Configurable UI with keybindings. Single binary.

What we like: CLI to help manage and share GPUs. Share GPUs on your machine and manage remote machines. Find available GPUs across a pool of resources and reserve them for your own use. Monitor usage and pipe metrics to Prometheus or Grafana. Access GPUs from containers. Supports over subscribing resources. Integrates with VSCode, Jupyter and other IDEs.

What we like: Exposes cloud object storage (S3 & S3 compatible, GCS, Azure Storage) as if it were a POSIX compatible filesystem with standard commands like copy, list, remove, etc. Appears as a new mounted filesystem plus a CLI for direct interaction (which offers better performance than a FUSE mount). Supports metadata like permissions, links, users, etc.

What we like: Full Postgres, but only a serverless model with compute and storage scaled independently. Branching from main makes it easy to prototype and test changes without worrying about the production branch. Integrates with Vercel preview environments for automatic branches per environment. Web UI for easy browsing & SQL execution. Hosted, but open source.

What we like: Add metrics to existing code with simple annotations or macros. Supports Rust, Go, Python, TypeScript, C#. Alerts and SLOs defined in code next to each instructed method. VS Code extension provides deep links to generated graphs. Can run locally, but designed to export to Prometheus.

What we like: The prompt is a native text field so you can click around and use shortcuts to move the cursor, highlight words, etc. Lots of small UI improvements e.g. the command pins to the top as you scroll. Each output is a “block” which can be shared and navigated. Get AI assistance for commands. Shell runs through SSH so you don’t lose all the benefits on remote servers.

What we like: Converts Markdown or Notion pages into type-safe data ready to be imported into an ESM module. Type safety means you can loop through pages and parse out JSON, Markdown, MDX. Can also pull from remote sources. Integrates into Next.js with fast, incremental builds & hot reload.

What we like: Protects runner workflows from exfiltration-style attacks by providing network observability for the runtime environment. Monitors files, process & network activity. Can block egress traffic (with allowlists), detect source code tampering, and compromised dependencies. Runs on GitHub hosted, self hosted, and VM runners.

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