955 tools · Sort Curated (free first)Catalog (raw)NewestMost starsStars/weekA–Z
AI-native browser automation that mixes code and natural language
AI Agents / Browser Automation
AI calls add latency and cost. The natural-language parts are only as reliable as the underlying model. Debugging AI-driven steps is harder than debugging selectors.
Open-source framework for LLM-driven browser agents
You need browser infrastructure—Browser Use is a framework, not a managed service. Token consumption scales with page complexity. Anti-bot measures will block you without stealth tooling.
Official Microsoft MCP server for Playwright browser automation
It is a control interface, not a complete solution. You still need browser infrastructure (local Chromium or Browserbase). No built-in session management, authentication, or scaling.
Memory infrastructure for AI agents that actually persists
AI Agents / Memory & Evals
External dependency for a core capability. Async processing adds latency. Platform optimizations are not in the open-source SDK. You are trusting Mem0 with potentially sensitive user data.
Open-source LLM observability you can self-host
License: the core is MIT, but anything under the ee/ directories is under a separate enterprise license — check which features you rely on before calling your deployment fully MIT. Self-hosting means self-operating—you are running Postgres, ClickHouse, Redis, and the app. Observability-first means evals are layered on, not central.
AI pair programming in your terminal with any model
AI Agents / Coding Agents
You are paying per-token at API rates—can exceed subscription costs on heavy use. No managed infrastructure; you are the ops team. Less polished than commercial alternatives.
VS Code extension for human-in-the-loop AI coding
Human-in-the-loop means constant interruptions. Large tasks require many approvals. The pace is slower than autonomous alternatives.
Episodic memory for agents that think across sessions
More complex to reason about than simple vector retrieval. The paging mechanism adds latency and orchestration overhead. Documentation assumes understanding of the original MemGPT paper.
Unified TypeScript SDK for building AI applications
AI Agents / Orchestration
Vercel-optimized, which is great on Vercel and requires more work elsewhere. Abstraction means some provider-specific features are harder to access.
The OG LLM orchestration framework
Abstraction layers add complexity. Simple use cases feel over-engineered, and the learning curve is steeper than rolling your own for basic RAG.
Stateful multi-actor agent workflows
The abstraction overhead is real. Debugging graph execution requires understanding the underlying state management, and simple agents become verbose.
Role-playing agents that actually ship
The simplicity cuts both ways. Complex inter-agent communication patterns require workarounds, and you are locked into CrewAI execution model.
Production NLP pipelines from deepset
Haystack strength is also its constraint. The framework assumes pipeline-based architectures; more exotic agent patterns require workarounds.
Data framework for LLM applications
The abstraction layers can be confusing. Index, query engine, retriever, synthesizer—the terminology requires investment to master.
Type-safe database access with killer DX
Next.js / ORM
Abstraction costs. Complex queries sometimes require raw SQL, and the generated client adds bundle size. Performance-sensitive applications need careful query optimization.
TypeScript ORM that feels like SQL
Less magic means more typing. Relation handling requires more manual work than Prisma. The ecosystem is smaller.
End-to-end typesafe APIs without codegen
Next.js / API
TypeScript only—this is not for mixed-language teams. The tight coupling means you lose the API as a standalone artifact.
Authentication for the web, framework-agnostic
Next.js / Auth
You are building the UI, handling edge cases, and managing the infrastructure. Provider quirks require debugging.
File uploads that do not make you cry
Next.js / Files & Email
You are depending on a third-party service for a core feature. Storage costs scale with usage, and egress gets expensive.
Open-source background jobs for Next.js
Next.js / Jobs
v3 was a significant breaking change. The managed platform costs scale with compute. Self-hosting requires maintaining infrastructure.
Modern Python APIs at startup speed
Python / Agent Frameworks & SDKs
The ecosystem assumes you will integrate pieces yourself—no batteries-included ORM or auth. Async programming has its own learning curve.
Data validation using Python type hints
Python / Data
The v1 to v2 migration was painful—significant API changes broke existing code. Some advanced validation patterns require understanding the internals.
Python packaging at Rust speed
Python / Tooling
Relatively new, so edge cases exist. Some older packages with unusual build systems may have issues.
Python linter faster than your test suite
Not every rule from every tool is implemented. Some teams have strong opinions about specific linter behaviors.
DataFrames that respect your CPU
Different API than pandas—existing codebases need rewriting. The ecosystem is smaller; some pandas integrations do not exist.
CLI apps with type hints and zero effort
Complex CLI patterns sometimes fight the abstraction. Very dynamic interfaces may need lower-level Click access.
Beautiful terminal output without the pain
Python / TUI
Terminal compatibility varies—some environments render poorly. The feature set is large; learning the full API takes time.
Async HTTP client for modern Python
Another dependency when requests works for simple cases. Some requests plugins do not have HTTPX equivalents.
SQL + Pydantic in one elegant package
Relatively young library, so edge cases exist. Complex SQLAlchemy patterns may need direct SQLAlchemy access.
The FastAPI alternative with batteries
Smaller community means fewer tutorials and Stack Overflow answers. Some FastAPI extensions need equivalents.
Build TUIs like web apps
Terminal constraints limit what is possible. Learning curve for the reactive model. Not every terminal renders correctly.
Shopify React framework for headless commerce
Shopify / Commerce
You are locked into Shopify architectural choices. Customization beyond their patterns requires deeper knowledge. Oxygen hosting limits deployment options.
Full stack React that Shopify acquired
The mental model shift from SPA patterns takes adjustment. Some React patterns do not translate directly. The ecosystem is smaller than Next.js.
The development tool every Shopify dev needs
Occasional bugs with authentication flows. Resource usage can be heavy. Some advanced workflows still require manual setup.
Customize Shopify checkout safely
The sandboxed environment limits what is possible. Some desired customizations are not supported by extension points.
Type-safe Shopify API without manual typing
Configuration complexity for advanced setups. Build step adds friction to the workflow. Large schemas generate large type files.
Official Node.js library for Shopify apps
Node.js only. Some edge cases require diving into implementation details. Version updates can break existing apps.
Open-source Firebase alternative built on Postgres
Databases / Postgres
The all-in-one convenience creates dependency. Complex queries hit performance limits. Self-hosting requires significant operational knowledge.
SQLite at the edge with libSQL
Databases / SQLite & Embedded
SQLite limitations still apply—no concurrent writes from different regions. The embedded replica model has a learning curve. Less battle-tested than Postgres.
The in-memory data store everyone uses
Databases / Key-Value & Cache
License: not MIT. Since Redis 8 the server is tri-licensed RSALv2 / SSPLv1 / AGPLv3 at your choice — AGPLv3 is the only OSI option and carries network copyleft; 7.4–7.x was RSALv2/SSPLv1 only. If you need BSD-3 Redis-protocol, look at Valkey. Memory-bound storage is expensive at scale. Persistence options have tradeoffs. Clustering adds complexity.
Open-source vector database with filtering
Databases / Vector
Operational burden of self-hosting. Smaller ecosystem than Pinecone. Some advanced features require understanding internals.
Column-oriented database for analytics
Databases / Analytics & Time-series
Not a general-purpose database—updates and deletes are expensive. Operational complexity for self-hosting. The learning curve for optimal schema design is steep.
In-process OLAP database
Not for OLTP workloads—it is analytics-focused. Single-node limits apply. Less ecosystem than traditional databases.
The most deployed database in the world
Single writer at a time limits write concurrency. Not designed for network access. Feature set is smaller than Postgres.
Container runtime that changed deployment
DevOps / Containers
Resource overhead compared to native. Security requires attention. Desktop licensing changes affected teams. Image size management is ongoing work.
Container orchestration at scale
DevOps / Kubernetes
Complexity is legendary. Small teams often do not need it. Operational burden is significant. The YAML can become unmanageable.
Infrastructure as code in real languages
DevOps / IaC
Smaller ecosystem than Terraform. Learning curve for infrastructure patterns. The state service is a dependency unless self-hosted.
Self-hosted Heroku alternative
DevOps / Deploy & PaaS
Self-hosting means self-operating. Some features are less polished than commercial alternatives. Single-server focus limits scale.
Free PaaS you can run anywhere
License: Apache-2.0 with an appendix that overrides it — no redistributing paid versions of CapRover, its paid features cannot be modified, and changes to the free features must stay free and open source. Read it before building on top. Documentation assumes Docker knowledge. Some advanced features require manual configuration. Less active development than alternatives.
Utility-first CSS that developers love
Design / UI
HTML becomes verbose. The utility-first paradigm requires adjustment. Complex components need extraction. Some designers find it limiting.
Copy-paste components built on Radix
You own the code, including the maintenance. Updates require manual copying. The paradigm differs from traditional component libraries.
Unstyled, accessible React components
Styling from scratch takes time. Learning the API requires investment. Some components have quirks.
Production-ready React animations
Bundle size is not negligible. Complex animations require understanding the system. Performance needs attention on mobile.
UI component workshop
Configuration complexity grows. Build times can be slow. Keeping stories updated requires discipline.
Beautiful open-source icons
Style might not fit every project. Some niches have gaps. Customization requires understanding SVG.
CSS-in-JS with build-time extraction
Different mental model from both Tailwind and traditional CSS-in-JS. Ecosystem is younger. Migration from other solutions takes work.
Dashboards for everything observable
Observability / Metrics
Dashboard sprawl becomes a maintenance burden. Learning PromQL or LogQL takes time. Self-hosting requires infrastructure.
Time-series metrics for cloud-native
Single-node storage limits scale. PromQL has a learning curve. High cardinality labels cause problems.
Vendor-neutral observability framework
Observability / Tracing
The specification is complex. Implementation maturity varies by language. Configuration requires understanding the model.
Systems programming without the footguns
Rust / Systems
The learning curve is steep. Compile times are slow. Fighting the borrow checker is frustrating at first.
Async runtime for Rust
Async Rust has a learning curve. Stack traces are confusing. Some patterns from other languages do not translate.
Web framework from the Tokio team
Less batteries-included than frameworks like Actix. Error messages can be cryptic. Some patterns require boilerplate.
Fast Rust web framework
Macro-heavy API differs from idiomatic Rust. The actor foundation is not always needed. Some community history caused concern.
Serialization framework for Rust
Compile times increase with heavy use. Error messages can be confusing. Some edge cases require manual implementation.
Compile-time checked SQL for Rust
Compile-time checking requires database connection. Migration story is simpler than some alternatives. Complex queries need understanding.
Build desktop apps with web tech and Rust
Webview inconsistencies across platforms. Rust learning curve for backend code. Younger ecosystem than Electron.
Full-stack Rust web framework
WASM ecosystem is still maturing. Debugging can be challenging. Smaller community than JavaScript frameworks.
Command line argument parser for Rust
Compile times increase with complex CLIs. Some advanced patterns require builder API. Error messages could be clearer.
Apache-2.0 OpenAI agent: CLI, IDE, app and cloud
The CLI is open source, but the models are not free: you pay through ChatGPT plan quotas or API spend. Codex Web runs on OpenAI’s cloud, not on your machine. The install.sh, brew and npm routes are supply-chain choices, so pin a release binary when that matters. Vs Claude Code or OpenCode: this is OpenAI’s first-party agent, tied to ChatGPT plans or OpenAI API keys.
Local-first Rust agent with MCP at its core
General-purpose agent means you configure it for your use case. You bring the model—Goose is the runtime, not the intelligence. Documentation is still maturing.
Self-hostable autonomous software engineer
Heavier than lighter agents like Goose. Self-hosting autonomous agents requires infrastructure and monitoring. The autonomy that makes it powerful also makes debugging failures harder.
14MB on-device tool-calling model
Not a chat LLM. Needle does one thing: parse user intent into tool calls. You still need the tools and the orchestration around it. Do not expect conversation or reasoning.
TypeScript agent runtime with typed agents and workflows
Framework, not a coding CLI. Mastra helps you build agents; it is not an agent itself. Learning curve for the runtime concepts. You are committing to their abstractions.
Google open-source terminal agent powered by Gemini
Gemini-bound lock-in—not model-agnostic like Goose or Crush. Consumer access (free/Pro/Ultra Google login) ended 2026-06-18; enterprise and API keys still work. Don't build on the old Google-login quota path. The OSS CLI remains. Antigravity CLI is the successor, not a 1:1 swap. Preview/nightly channels move fast; pin stable for production workflows. Enterprise path pushes you toward Vertex AI and Google Cloud project setup.
Official Chrome DevTools as an MCP server for coding agents
chrome-devtools-mcp@1.8.0 engines: "^20.19.0 || ^22.12.0 || >=23". 20.16 and 20.17 fail; 20.19 LTS is in engines. “Node ≥ 22.12” and “Node 20 fails” are both too blunt — README “LTS” is marketing; engines is the catch. A CLI is provided for use without MCP; official CLI docs call it experimental. Complementary to Playwright MCP —DevTools-grade traces, Lighthouse, heap snapshots, and --autoConnect, not a generic scraper or a Playwright replacement. Officially supports Google Chrome and Chrome for Testing only. Exposes browser content to the MCP client—do not point it at sensitive sessions. Usage statistics on by default (opt out with --no-usage-statistics). Needs a current Chrome.
Charm-grade TUI coding agent with LSP and mid-session model switch
Licensed FSL-1.1-MIT (competing-use restriction; source-available; MIT after two years—not OSI open-source). Pre-1.0 energy—config is migrating from JSON to crushrc Bash. Not a fully autonomous SWE agent like OpenHands; you stay in the loop. Hyper is Charm own model path if you want a subscription. Metrics on by default (DO_NOT_TRACK / CRUSH_DISABLE_METRICS to opt out).
Typed Python agent loop with a snap-on Coder harness
ACP (Agent Client Protocol, for editors like Zed) is experimental: it lives under pydantic_ai_harness.experimental.acp, may change or be removed in any release without a deprecation period, and importing it emits HarnessExperimentalWarning. Coder is a capability you assemble, not a turnkey SWE agent like OpenHands. Logfire is the convenient observability path; OpenTelemetry works with any backend. Do not confuse this gem with Pydantic validation.
Git worktrees that spawn an agent in one switch
On Windows, `wt` is Windows Terminal's command. The installer ships `git-wt` to avoid the collision (`winget install max-sixty.worktrunk` then `git-wt config shell install`); you can also disable the Terminal app-execution alias. Project hooks require first-run approval. This is worktree plumbing, not a coding agent.
Vercel Labs Rust CLI with compact a11y refs for agents
Default idle timeout is about one hour: the headless daemon shuts down and discards transient tabs/state unless you passed `--restore` (or another restore key). Headed, Safari/iOS WebDriver, and user-attached browsers are exempt; cloud-provider browsers are not. Tune with `--idle-timeout` or `AGENT_BROWSER_IDLE_TIMEOUT_MS`; `0` disables. This is CDP Chrome, not stealth—anti-bot pages will still block you.
TypeScript auth that lives in your app, not a rented IdP
The library is free; dashboards, audit, and SSO add-ons are the paid wedge. Starter audit retention is 1 day. This is not a hosted IdP — you still own the database and the incident.
Tiny TypeScript web framework that runs on every runtime
Libraries / Web Frameworks
Not Next.js. No filesystem router, no RSC, no batteries. You bring auth, ORM, and deploy. The Cloudflare-first energy is real — Node works, but the happy path is an edge runtime.
Official Stripe terminal for webhooks, events, and API objects
Payments / Billing
The CLI is free; card charges are not. See stripe.com/pricing for processing rates. Live mode needs a real secret. Dispute fees are on Stripe, not on this binary.
HTTP pub-sub notifications you can curl from cron
Comms / Notifications
Anonymous topics are passwords — guessable names leak other people's alerts. Public ntfy.sh rate-limits; reserved topics need Pro. Dual license means you pick Apache-2.0 or GPLv2, not Apache-only.
MIT HTML5 2D game framework with scenes, physics, and tilemaps
Graphics & 3D / Game Engines
Phaser 4 replaced the v3 renderer/FX/mask stack — v3 games need the migration guide. Phaser Editor is a separate commercial desktop product, not the OSS engine. The homepage can Cloudflare-gate a raw fetch; docs and GitHub are the source of truth.
Apache-2.0 merchant-of-record billing for indie and AI products
No first-party CLI in the docs index — SDKs, MCP, and API only. Starter take-rate sits on top of card-brand costs. Polar is MoR, so you do not keep the Stripe account relationship. International cards add extra. Payouts have their own cut.
SQLite backend, auth, and admin UI in one Go binary
SQLite is the database. Concurrent writes and multi-region are not the product. There is no official hosted PocketBase Cloud. You run the binary, you own backups, you own the disk filling up.
Rust formatter and linter that replaces Prettier plus ESLint
DevOps / Tooling
Not a 1:1 ESLint plugin ecosystem. Some rules and framework plugins do not exist yet. Dual-license is MIT OR Apache-2.0 at your option — there is no single LICENSE file at the repo root.
Deploy Docker containers to your own VMs with one CLI
You still run Docker hosts. This is not a PaaS. Networking, disks, and what-if-the-VM-dies remain your problem. Kamal 2 changed proxy defaults — read the current docs, not a 2024 blog post.
Fair-code workflow automation you can self-host
DevOps / CI/CD
Sustainable Use License is not OSI. Use and modification: internal / non-commercial / personal. Distribution only free of charge for non-commercial purposes. Files with .ee. in the name need a separate Enterprise License. It is not open source.
Apache-2.0 payment orchestrator you can self-host
Payments / Orchestration
Community Edition means you run PCI scope. Cloud and Self-Host Enterprise are Contact Us. The 500+ global enterprises line is Juspay production experience, not a Hyperswitch-customer logo wall.
MPL-2.0 identity platform with a 50k-MAU free Cloud
Cloud Free is for starting out. Passkeys, hiding branding, orgs, MFA, and enterprise SSO live as Pro add-ons. MPL-2.0 is file-level copyleft, not MIT.
Apache-2.0 realtime rooms, SFU, and agents
Comms / Realtime
Self-hosting an SFU is ops-heavy. Cloud Build pricing and free allowances are not confirmed here; check the vendor site. Do not assume Cloud is free.
MIT realtime library with fallbacks, not a hosted product
You bring the host. Horizontal scale needs Redis (or equivalent) adapter. This is not LiveKit and not a managed pub-sub. CORS, sticky sessions, and polling surprises remain your bugs.
AGPL-3.0 self-hosted newsletters and transactional mail
AGPL-3.0 is copyleft — network use means you share modifications. You operate Postgres, SMTP, and bounces. There is no official hosted Listmonk Cloud.
MIT 2D WebGPU/WebGL renderer, not a game engine
Graphics & 3D / Renderers
A renderer, not a game engine. Bring physics, audio, scenes, netcode. If you wanted Phaser, this is the wrong layer.
Apache-2.0 3D engine for the web, now on v9
Heavier than a 2D starter. docs.babylonjs.com (with an s) has returned 500; working docs host is doc.babylonjs.com. Editor pricing was not verified here, so it is omitted.
MIT WebGL2/WebGPU engine plus an optional hosted Editor
Do not conflate the MIT engine with the hosted Editor. Private cloud projects are the paid line (Personal 15 USD/month; Organization 50 USD per seat/month). Cancel and private projects lock until you resubscribe or make them public.
MIT Node multiplayer rooms with state sync
Graphics & 3D / Multiplayer
A server framework, not a renderer. Colyseus Cloud has no free tier — it starts at 15 USD/mo. Capacity depends on your code, not a marketed CCU cap.
MIT successor to Kaboom for playground-first 2D games
Two lines: stable v3001 vs v4000 still alpha. Official host is kaplayjs.com, not kaboomjs.com. Named homepage titles are testimonials, not a studio showcase.
MIT end-to-end typed TypeScript RPC
Libraries / RPC
TypeScript-first. Not a drop-in for every tRPC plugin. You still choose the HTTP server (Hono, Next, etc.). Do not confuse it with a backend-as-a-service.