Console

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