Console

What we like: Build product experiments with feature flags and testing scenarios. Set up dynamic configs which can be modified in real time from the dashboard. Includes session replays and web analytics in the same product. Send arbitrary metrics for analysis and building experiments around. Can also be managed via a CLI.

What we like: Deploy a single binary to set up an S3 compatible object storage server. Designed for data redundancy across multiple nodes. Doesn’t assume a fast network - can be deployed on commodity servers (cloud, VMs, bare metal, etc) - and doesn’t require high spec servers. Use any existing S3 client. Open source.

What we like: Query, join, export, import data from databases, Excel, CSV. Inspect and visualize metadata e.g. table structure. Diff rows and tables within databases. Import across formats e.g. Excel into Postgres. Copy, truncate, drop tables. Plugin system for sources. Open source.

What we like: Faster runners using more up to date CPUs. Supports faster caching of jobs (up to 400MB/s vs GitHub 100MB/s) and colocation of caching physically closer to the runners. Includes a Docker pull-through cache. Cheaper runner costs. Custom caching actions optimized for Rust, Gradle, Zig. NVMe backed I/O.

What we like: Converts Markdown content into a fully-featured website with a digital garden philosophy. Includes search, graph view, wikilinks, backlinks, Latex, syntax highlighting, RSS. Generates static output that can be hosted anywhere. Build & run locally with hot reloads. Customizable colors, layouts and theming.

What we like: Graphical TUI for executing HTTP requests. Keyboard-first navigation. Request collections stored in local files for easy sharing, versioning, issuing common requests. Supports environment variables for dynamic configuration e.g. changing URLs. Quick access command palette. Can import OpenAPI specs.

What we like: JS component that can be embedded in any web application. Zero dependencies. Customizable using HTML & CSS since it’s all just JS. Define your own commands with custom functions. Can be automated to provide realistic demos or animations of terminal UIs.

What we like: Define jobs and workflows in Go which gives you all the functionality of Go e.g. types, calling functions, defining retries in code, etc. Transactional enqueuing helps avoid edge case failures. Queue management with error handling, scheduled jobs, snoozing jobs. Clients can subscribe to events using Go channels. Includes a management UI.

What we like: Hooks into BPF syscalls to collect runtime stats every second. Shows runtime, events per second, CPU utilization of all running eBPF programs. Real time tabular view. Metrics can also be graphed. Collects stats only whilst running to minimize the performance impact.

What we like: Reads in environment variable files. Runs as a CLI rather than a library so it works with any language. Supports encrypted key values so the environment variable file can be committed to Git. CLI also supports other commands e.g. get and set. Open source and works across platforms.

What we like: Supports synthetic API monitoring and real user monitoring with an embedded JS snippet. Monitors can be made public for status transparency. Users can subscribe to status pages. Supports alerting and notifications of issues via Discord, Slack, SMS, PagerDuty. Open source - self-host or use their cloud service.

What we like: Reconfigures Ubuntu 24.04 with a more visually appealing and functional UI. Consistent themes across applications including terminal, browser, code editor, backgrounds. Installs common applications e.g. Alacritty, Docker, GitHub CLI. Sets up proper font configs. Includes a UI for configuring everything.

What we like: Terminal uses an actual text input field so you can use normal shortcuts. AI agent mode can take multi-step actions based on natural language requests. Proposes commands before executing them. Reviews output so the next command/step is based on the real results. Can learn CLIs based on help output. Command search (history, workflows, notebooks).

What we like: Build web app functionality by using augmented HTML attributes rather than complex JS frameworks. Supports HTTP requests, WebSockets, server sent events, CSS transitions, etc all in HTML. No dependencies. Has built in form validation. Events system linked to logging for debugging. Open source.

What we like: Define multi-step sync & async workflows and tasks in code and have them executed. Durable against failures with granular step by step retries. Sleep & suspend code for arbitrary lengths of time (even months). Single (Rust) binary which can be deployed on k8s or AWS (EC2, Lambda). Open source and cloud service.

What we like: Optimized searches for developers based on known tech stack and tool integrations e.g. GitHub. Choose whether to use on-device only or cloud augmented LLM searches. Standalone desktop app and IDE integrations. Can optionally scan workflows in other apps e.g. discussions in chat, web browsing, to add context to searches.

What we like: CLI for managing app deploys. Can be as simple as pushing to Git which triggers a build & deploy. Uses runtime specific virtual environments e.g. virtualenv for Python, separate GOPATH for Go. Uses a Procfile to manage multiple processes. Configure environment variables, virtual hosts, and SSL. Works cross-platform. Really small codebase so it’s easy to understand.

What we like: Anonymizes data based on analyzing the source. Generates realistic synthetic data based on your schema. Configurable mapping and transformation to control how data is represented in the anonymized / synthesized form. Can provide representative subsets of real data for use in test rather than needing a full copy of the huge prod database. Open source so can be run independently.

What we like: No background worker needed - it’s a Postgres extension that bundles functions. Supports exactly once delivery. API compatibility with AWS SQS. Each queue is its own table. Messages can be archived for long term retention. Supports partitioned queues.

What we like: Based on default browser styling, but easy to customize. Provides good looking defaults. Lightweight, no build step, can be reduced by excluding unused elements. Covers a wide range of HTML elements. Includes syntax highlighting classes. Dark mode support. Tea-based name.

What we like: Live dashboard with views based on GitHub filters - show PRs & issues. Customizable columns, keybinding actions, refresh interval. Themable. Can perform basic actions e.g. comment, assign, merge. Extension built on top of the gh CLI so you don’t need extra creds. Watch issues to get notifications on check completion.

What we like: Simple API to issue search queries to LLMs from code: exa.search(“query here”). Can auto-suggest prompt changes to optimize searches e.g. keyword searches don’t work well with LLMs. Avoids the need for prompt chaining. Has specialist indexes for things like companies, GitHub repos, papers, blogs, jobs.

What we like: Supports logs, traces, and metrics using custom SDKs or OpenTelemetry. Parses JSON logs for structured queries. Also supports session reply and error reporting. Uses ClickHouse as the storage layer. Create custom data visualizations. Includes alerting via email, Slack, PagerDuty.

What we like: Set up a .tool-versions file in your repo and the asdf CLI manages all the runtimes scoped to that directory. Handles things like Node.js, Ruby, Elixir runtimes. Allows you to have multiple runtime versions for different projects and manage how they are updated.

What we like: Browse files from the terminal. Pin folders and navigate visually. Configurable keyboard shortcuts for moving around, spawning multiple panels and performing actions like rename, copy, delete. Includes a clipboard manager. Inspect file details. Themeable. Available in package managers and as a single binary.

What we like: Jira/GitHub alternative with issue tracking, project boards, and milestones. Includes pages/wiki functionality and file hosting drive for attachments. Optional inbox functionality for managing requests. You can sync issues to GitHub. Open source and can be self-hosted using Docker or k8s.

What we like: Analyzes PRs and adds LLM-generated reviews. Includes a high-level summary, per file summary, and specific-line comments where appropriate. Can respond to follow up questions in-line within the PR. Considers the context of linked issues to evaluate whether they are solved by the PR. Configurable via a YAML file.

What we like: Shell scripting with an interactive shell. Distributed as a static (Go) binary so works on (and can easily be shipped to) lots of platforms. Shell shows errors before execution e.g. undefined variables to avoid unexpected behavior. Built-in searchable directory and command history. Also has a file manager UI.

What we like: Browser extension development framework. Allows you to write extensions for most browsers using TypeScript / JS, React and CSS. Supports calling into WebAssembly. Dev command supports live reload. Helps build & package for distribution.

What we like: Wraps around Nix to provide declarative developer environments. Automatically activates environments when entering the directory. Manages scripts, Git hooks, running services, containers. Supports tests & process management. Environments per directory can be imported into a main environment in monorepos.

What we like: Create composable pipelines of tasks and process them. Run tasks in series and/or parallel to break complex flows into multiple pipelines. Supports file watching to run workflows as things change. It’s a framework on top of JS so you get the full power of JS - process execution, calling APIs, other modules, etc. Open source.

What we like: Easily define & execute HTTP requests in plain text. Chain requests, evaluate queries, define assertions. Built-in manipulation tools for HTML, JSON, REST, SOAP, GraphQL. Export reports for response time monitoring. Supports request templates & variable injection. Open source.

What we like: Consumer & B2B SaaS auth APIs, with separation of top-level org as a unit of multi-tenancy. This allows different configs & users per org within the same top-level project. Supports social auth, magic links, passkeys, SSO, SCIM. Also includes RBAC permissions. Customizable JWT claims. Management UI has dark mode.

What we like: Caches calls to NPM which makes resetting Node projects much faster on subsequent downloads. Particularly good for containerized applications where you regularly prune containers for a fresh dev environment. Runs as a lightweight container. Can override public packages.

What we like: Generates idiomatic Go code based on your database schema and desired queries. Translates SQL to type-safe Go code. Interface to the generated code feels like proper Go. Can run static analysis on schema changes to detect breaking changes across the codebase. Useful tools to help ensure codegen is up to date and highlights SQL anti-patterns. Open source.

What we like: Builds Docker images in the cloud rather than on your local machine. Links to Docker Desktop & CLI for transparent usage. Shared cache within a team speeds up builds for all users. Managed multi-arch builders for AMD & ARM platforms. Smart layer caching only builds what’s changed. Also integrates with CI.

What we like: Use any runtime - Node, Bun, Cloudflare Workers, Vercel, Lambda, etc - with a (mostly) consistent API abstraction. Zero dependencies. Uses the Web Standard API. Supports sophisticated routing configurations, middleware, client components, validation, RPC. Includes a testing framework.

What we like: Build tasks and workflows in code (currently Python, Go, TS). Each stage of a workflow is independent and can be run durably and retried without losing progress so far. Run your own workers so you control underlying resources, location, and data privacy. Manage concurrency and rate limiting of steps to control resource consumption. Cloud service, but you can also run the control plane yourself.

What we like: Flexible approach to building authorization logic with a DSL. No need to rely on a single centralized service - centralize the logic, which can return “yes, if” for validation with local data. Makes it easier to reason about complex auth across microservices. SDKs for Node, Python, Go, Ruby, and .NET. Check in your auth .polar files to Git.

What we like: Creates & manages virtual environments and installs packages into them. Makes it easy to manage devtools, libraries, runtimes without conflicts. Handles dependency management for any installed packages. Easy to share environments with other people. Environments can be defined declaratively in a config file.

What we like: Visual, browser-based editor for designing database schemas. Supports MySQL, PostgreSQL, SQLite, MariaDB, SQL Server, plus object relational databases with JSON schemas. Create templates for common designs. Export the results to SQL to actually create the database from your work. Free, open source, you can host it yourself.

What we like: Single (Rust) binary for managing dotfiles. Works cross-platform with OS specific config options. Sync across machines with Git. Supports yaml, toml, or json config files. You can create files from templates using the Handlebars syntax. Configs can have dependencies before they are installed. Open source.

What we like: Generates API docs from your OpenAPI/Swagger file. Runs through an LLM to also generate detailed guides alongside the reference. Design can be customized with access to CSS variables. Includes an editor for real-time collaboration on the generated output. The generator and the output are open source, so you can self-host or use their hosted docs service.

What we like: Simplifies publishing workflows for npm packages. Performs lots of useful checks like checking for the release branch, clean working directory, running tests, etc. Handles version bumps, GitHub releases, packaging, tagging. Includes 2FA. Handles rollbacks in case of failure.

What we like: Scale Postgres horizontally by configuring shards. Wire protocol compatible so all existing clients work - they don’t need to be shard aware. Includes connection pooler so you can replace PgBouncer et al. Can run multiple routers for HA. Live config reloading.

What we like: 3.0 release includes new layout components (box, flex, grid, section, container), new colors, and new components (skeleton, spinner, etc). Type safe via component props rather than utility classes e.g. as in Tailwind. Radix is a multi-layer framework so you can always get at the unstyled React primitives, icons, and colors.

What we like: Makes it easy to build sophisticated text editing features like undo, real-time collaboration, history tracking & versioning, and conflict resolution of multiple edits. Available as a Rust library as well as a JS package which uses WASM. Allows offline editing.

What we like: Drop-in web UI for managing and observing Kafka clusters, topics, connectors, consumer offsets, etc. Easily edit & reprocess messages. Graphing and alerting on topics & partitions. Cluster managers can set up self-service for developers with different environments. Proxy gateway enables ACLs, RBAC, auditing, encryption, masking, load balancing.

What we like: Download a URL to a single HTML bundle. Embeds all the assets into the file so it can be loaded offline (or more likely, when those resources disappear or change). Options to exclude assets like videos and audio. Can block domains e.g. to block ads or other included resources. Single binary CLI.

What we like: Underlying platform for running containers (with Podman Desktop as a GUI). Now supports the latest macOS VM framework. Pasta networking backend now the default allowing rootless / unprivileged connectivity. Supports various OCI formats for running various containers. Simplifies k8s locally.

What we like: Easily interact with APIs - manipulate requests, params, response. Build collections with different environments which are stored in a plain text markup language locally. Supports reading secrets. Includes scripting support for complex API interactions. Also has a CLI.

What we like: S3 compatible API so all your existing S3 tooling works as a drop-in. Key differentiator is the auto-migration & caching of objects to the region where they’re most used. Fixed pricing globally and no internet ingress or egress fees. Buckets are private by default (supports signed URLs), but can be public.

What we like: Well designed native macOS app focused on Git diffs. Easily compare files and branches. Visual commit

What we like: Modern, open source package registry for JS/TS modules. ESM-only. Supports multiple package managers inc. npm, yarn, pnpm, Bun, Deno. Secure publishing workflows by default. Auto API doc generation and scoring to encourage best practices. Open source.

What we like: Continually runs in the background, watching Rust files for warnings or errors. Also runs tests. Sits in your terminal. Configurable commands and watch directories. Supports .gitignore. Can run multiple instances e.g. for different build targets. Nvim plugin available. Open source.

What we like: CLI to export data from one source database and load it into another. Lots of different sources & destinations e.g. Postgres to DuckDB, SQLite to BigQuery, etc. Supports various incremental loading strategies - append, merge, delete+insert.

What we like: Lots of integrations for ingesting alert triggers. Built-in notifications for email, SMS, phone, mobile app. On-call management, scheduling, escalations. In-bound phone option to route to on-call responder. Slack & Teams ChatOps. Create hosted status pages with custom domains.

What we like: Easily access core Git commands via an interactive terminal interface. Supports most common commands with keybindings to quickly work through tasks. Inspired by Magit.

What we like: Integrates with Git, Tmux, and your editor to manage the project file tree. Preview files with syntax highlighting, file fuzzy search, run commands across the project, explore the files with support for show/hide hidden files and .gitignore. Keybindings and custom command support.

What we like: Minimal setup required to get detailed cost reports. Breakdowns by service, account, environment, resource. Segment by team and calculate unit costs. Anomaly detection and notifications e.g. weekly Slack reports. Autopilot auto buys, applies, sells reservations to optimize spend. Terraform provider.

What we like: Vendor executables without checking large binaries into source control. Makes it easy to standardize & pin specific dependency versions e.g. Node or an internal-only runtime build. Downloads and verifies the binaries. Can be generated using the included GitHub Actions workflow.

What we like: Make text edits across many files in one go. Can be connected to fzf and a highlighter/pager to show the edits visually. Previews the changes by default so you can verify. Or pass a commit flag to make the changes right away. Supports regex replacements.

What we like: Serverless access to GPUs for training and inference. Support for pipelining to allow transcriptions & encoding. Access to the latest LLMs and LoRA for fine-tuning. Supports parallel execution, cron jobs, queues. SDK allows easy switching between local and remote calls.

What we like: Colorizes and highlights various common log formats. Can combine multiple (large) log files. Keybindings for jumping around and triggering search. Search supports regex. Can also tail.

What we like: Introduces concept of virtual branches which work off base and allow simultaneous changesets which can be committed & pushed separately, even in the same file. GUI makes it easy to understand and allows drag & drop of changes to other branches.

What we like: Set of common components for email templates e.g. tables, headings, images, code. Can render Markdown. Components work across all major email clients. Local preview web UI for live development. Supports Tailwind for customization. Can convert existing React components.

What we like: Lightweight library to benchmark TypeScript applications. Supports before & after hooks across tasks and globally. Reports stats for each run e.g. min, max, percentiles. Supports listeners on events. Open source.

What we like: Nice enhancement to the ping command - adds a graph. Alternative cmd flag to measure the execution time of arbitrary commands. Customizable colors. Available from a range of package repos and as a single binary.

What we like: Easily implement a globally distributed event gateway without worrying about scaling and redundancy. Direct incoming events to arbitrary destinations. Visual console to inspect requests and results. Options to throttle, transform, filter, delay, and replay event processing.  CLI for local development. Pause event processing for maintenance and backfill later.

What we like: Create your own private network for all your devices, servers, environments. Simplify SSH login with auto managed keys linked to your identity provider. Define network rules for who can access what. Access private resources without opening firewalls. Connect ephemeral CI workflows to your network for access to resources e.g. test databases. Clients for all platforms.

What we like: Markdown-like so it’s not something brand new to learn. Built-in headless components like tables, buttons, videos, layout grids. Separates content from design and based around web components. Avoids MDX mixing complex imports and JS. Minimalist progressively enhanced content-first philosophy.

What we like: Define secrets in one place and sync them everywhere they’re consumed. Supports different environments for prod, staging, prod, etc. Track versions and change history. Automated rotation for common services e.g. AWS, GCP, Twilio. IDE integration and CLI for launching processes with secrets injected into the environment. Cached for offline use.

What we like: Block-based text editor designed for developers - like buffers in other editors. Global hotkey to show/hide. Code is auto-detected, syntax highlighted and auto-formatted. Blocks can run calculations e.g. unit or currency conversions. Runs on macOS, Linux & Windows.

What we like: Write functions in any language that can be compiled to WASM e.g. Go, Rust, Zig. Tarmac adds platform features like callbacks, logging, k/v store, SQL and HTTP fetching. Functions get exported to WASM then deployed using Tarmac running as a container (or outside of Docker if you prefer). Chain together functions into services.

What we like: CLI for quickly creating standardized commits in conventional commit format. Define config in a repo JSON file e.g. to define formats and scopes. Can infer types and issue numbers from branches. Colorful interface. Emoji can be used, but also disabled.

What we like: Simple route definition with handlers that accept params, request methods, catch all, or more complex route rules. Includes middleware support, a storage layer for abstracting data storage, and a cache API. Handles static assets. It powers the Nuxt framework so is proven in production. Deployment adapters for Edge, Node, Bun, Deno, and lots of platforms.

What we like: Visual representation of how your Rust code is executing with a full call tree. Capture all parameters and return values for all functions. Makes it easier to trace errors through Results so you don’t lose the context of the error. Only traces user code avoiding getting bogged down in libraries.

What we like: CLI to deploy any containerized app to any server (VM, bare metal, etc). Works with a single or many servers. Handles rolling deploys with health checks. Includes Traefik to proxy traffic to the container. Supports persistence e.g. for databases and volumes. Much simpler than figuring out k8s.

What we like: True drop-in replacement for grep - it focuses on the UX to make it easier to search. This means an interactive TUI by default. Lots of small UX tweaks vs GNU grep e.g. matching unicode by default, can search archives like .zip, can search PDFs, docs, and other file formats. Different outputs e.g. JSON, XML.

What we like: CLI & GUI to make submitting stacked Pull Requests easy. Auto-restack makes rebasing main into multiple branches a single command. Submit PRs and request reviews from the CLI. Trigger the merge queue from a GitHub tag which handles rebasing, status checks, and then merging sequential PRs with no interaction.

What we like: Lightweight web framework for building docs. Built-in client-side search. Customizable code highlighting with support for annotations and diffs. Write using Markdown, Markdoc and MDX. Built on top of Astro so it supports UI components e.g. React, Vue, Svelte, and server side rendering.

What we like: Create web endpoints using Rust, bringing strong typing and robust compiler support to web applications. Routes are normal Rust functions with attributes defining their behavior e.g. as a GET handler. Strong typing of inputs allows for easy validation, typed URIs, and reading data into Rust data types, particularly useful for requiring authentication and defining authorization.

What we like: Sync your shell history between machines - E2E encrypted, or host your own sync-server. Filter by host, directory, fuzzy search. Search from the CLI or use the interactive TUI. Generate fun stats e.g. most used commands (last 24hrs & full history). Import existing history.

What we like: Combines ping and traceroute to visualize the network path to a target. Inspect each hop with stats for each, including AS lookup. Analyze the status of each hop with a graph as the tests run. Export JSON, CSV, text. Packages for all major platforms, single binary, open source.

What we like: Like an API gateway, but for databases - provides connection pooling and caching. Can be containerized and exports observability primitives (logging, Prometheus metrics, otel traces). Works at the transport layer so is protocol agnostic, with Postgres as the first supported protocol. Open source.

What we like: Embeddable Rust library with no infrastructure dependencies. Supports ACID compliant transactions. Includes save points and rollback support. Allows for concurrent readers & writers without blocking.

What we like: If you know jq then you can use jaq to manipulate, process, and work with JSON. Focused on simplicity and correctness, avoiding some of the quirks of jq e.g. some crashes and how numbers are handled. Helps to avoid rounding errors. jaq is written in Rust vs jq written in C.

What we like: Focused on websites rather than web applications. Means it can optimize for server-side rendering, no-JS by default, and maintain a UI framework agnostic approach. Dynamic islands allow bringing in UI components for interactivity e.g. React, Preact, Vue, etc. TypeScript type-safety for Markdown.

What we like: Development mode to help as you build a model e.g. create test cases and data validations. Validate performance and quality of responses. Monitoring mode to help once models are deployed e.g. performance, checking expected responses. Get notifications about problems. Can auto instrument OpenAI calls.

What we like: Designed to be an easy systems language. Provides low-level control over memory (without GC) whilst still offering safety and avoiding ownership. Uses result types for error handling. Compilation metadata included with source code to avoid needing to rebuild every time. Has a built in module system.

What we like: Makes it easy to launch macOS CI VMs on Apple Silicon. Connects as a self-hosted runner for GitHub, BuildKite and GitLab. Can also run a script to start a runner for other systems. Significantly faster and cheaper than paying for the hosted runners! Open source.

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