# devtools/

> A curated, open-source directory of developer tools, books, courses, and resources.

Source: https://devtools.directory/
License: MIT

## Sections

- [Tools](https://devtools.directory/tools/) — Developer tools, editors, CLIs, databases, and more
- [Languages](https://devtools.directory/languages/) — Programming language profiles with associated tools and frameworks
- [Frameworks](https://devtools.directory/frameworks/) — Web, backend, and fullstack frameworks
- [Stacks](https://devtools.directory/stacks/) — Curated technology stacks
- [Learning Paths](https://devtools.directory/paths/) — Structured learning paths for developers
- [Books](https://devtools.directory/books/) — Technical books for developers
- [Courses](https://devtools.directory/courses/) — Online courses and training
- [Resources](https://devtools.directory/resources/) — Guides, cheatsheets, newsletters, podcasts

## Tools (7 entries)

- [Docker](https://devtools.directory/tools/docker/) — Platform for developing, shipping, and running applications in containers.
- [Neovim](https://devtools.directory/tools/neovim/) — Hyperextensible Vim-based text editor with Lua scripting, LSP support, and a thriving plugin ecosystem.
- [Next.js](https://devtools.directory/tools/nextjs/) — Full-stack React framework with server-side rendering, static generation, and App Router.
- [PostgreSQL](https://devtools.directory/tools/postgresql/) — Advanced open-source relational database with extensive features and ACID compliance.
- [React](https://devtools.directory/tools/react/) — JavaScript library for building user interfaces with a component-based architecture.
- [Redis](https://devtools.directory/tools/redis/) — In-memory data structure store used as database, cache, message broker, and streaming engine.
- [Visual Studio Code](https://devtools.directory/tools/visual-studio-code/) — Free, open-source code editor by Microsoft with extensions, debugging, and Git integration.


## Languages (100 entries)

- [ABAP](https://devtools.directory/languages/abap/) — SAP's proprietary language for business application programming — the backbone of SAP ERP systems worldwide.
- [ActionScript](https://devtools.directory/languages/actionscript/) — ECMAScript-based language that powered Flash — the dominant platform for interactive web and game content in the 2000s.
- [Ada](https://devtools.directory/languages/ada/) — Safety-critical systems language mandated by the US DoD — used in aerospace, defence, and railway control systems.
- [Agda](https://devtools.directory/languages/agda/) — Dependently typed proof assistant and programming language — used for formalising mathematics and verifying software correctness.
- [Apex](https://devtools.directory/languages/apex/) — Salesforce's proprietary Java-like language for building business logic on the Salesforce platform.
- [APL](https://devtools.directory/languages/apl/) — Array-oriented language using a unique notation of mathematical symbols — extraordinarily concise, operating on entire arrays at once.
- [Assembly](https://devtools.directory/languages/assembly/) — Human-readable representation of machine code — the lowest-level language above raw binary, essential for OS kernels, firmware, and reverse engineering.
- [AWK](https://devtools.directory/languages/awk/) — Pattern-action text processing language — a one-liner powerhouse for parsing and transforming structured text files.
- [Ballerina](https://devtools.directory/languages/ballerina/) — Cloud-native language from WSO2 — built-in network types, service definitions, and JSON/XML handling for integration work.
- [Bash](https://devtools.directory/languages/bash/) — The GNU Bourne Again Shell — the default scripting language of Linux and macOS automation.
- [C](https://devtools.directory/languages/c/) — The foundational systems language — close to the metal, fast, and still driving operating systems, embedded firmware, and compilers.
- [Carbon](https://devtools.directory/languages/carbon/) — Google's experimental C++ successor — designed for bidirectional C++ interoperability and a safer, more modern syntax.
- [Chapel](https://devtools.directory/languages/chapel/) — Parallel programming language from Cray/HPE — designed for high-performance computing on multicore and distributed systems.
- [Clean](https://devtools.directory/languages/clean/) — Purely functional language from the Netherlands with uniqueness types for safe in-place mutation without monads.
- [Clojure](https://devtools.directory/languages/clojure/) — Pragmatic Lisp on the JVM — immutable by default, REPL-driven, and built for concurrent data transformation.
- [COBOL](https://devtools.directory/languages/cobol/) — Business-oriented language from 1959 — still processing the majority of the world's financial transactions.
- [CoffeeScript](https://devtools.directory/languages/coffeescript/) — Syntactic sugar that compiles to JavaScript — introduced many clean features later adopted by ES6.
- [Common Lisp](https://devtools.directory/languages/common-lisp/) — The standardised, multi-paradigm Lisp — one of the most powerful and flexible languages ever created.
- [Coq](https://devtools.directory/languages/coq/) — Interactive proof assistant based on the Calculus of Constructions — used to formally verify compiler correctness and mathematical theorems.
- [C++](https://devtools.directory/languages/cpp/) — Systems language extending C with classes, templates, and the STL — the language of game engines, browsers, and high-frequency trading.
- [Crystal](https://devtools.directory/languages/crystal/) — Statically typed language with Ruby syntax — as fast as C, as readable as Ruby.
- [C#](https://devtools.directory/languages/csharp/) — Microsoft's modern, type-safe language for .NET — used in enterprise backends, game development with Unity, and cross-platform desktop apps.
- [D](https://devtools.directory/languages/d/) — Systems language designed as a successor to C++ — safe, fast, and with built-in concurrency and metaprogramming.
- [Dart](https://devtools.directory/languages/dart/) — Client-optimised language from Google — the foundation of Flutter for cross-platform mobile, web, and desktop apps.
- [Delphi](https://devtools.directory/languages/delphi/) — Object Pascal RAD environment from Embarcadero — used for cross-platform native desktop and mobile applications.
- [Eiffel](https://devtools.directory/languages/eiffel/) — Object-oriented language built around Design by Contract — preconditions, postconditions, and invariants are first-class language features.
- [Elixir](https://devtools.directory/languages/elixir/) — Functional, concurrent language built on the Erlang VM — designed for fault-tolerant, distributed, low-latency systems.
- [Elm](https://devtools.directory/languages/elm/) — Functional language that compiles to JavaScript — famous for its zero-runtime-error guarantee and helpful compiler messages.
- [Erlang](https://devtools.directory/languages/erlang/) — Concurrent, fault-tolerant language from Ericsson — the foundation of the BEAM VM that also powers Elixir.
- [Factor](https://devtools.directory/languages/factor/) — Stack-based concatenative language with a rich interactive environment — programs are composed by concatenating words.
- [Fennel](https://devtools.directory/languages/fennel/) — Lisp that compiles to Lua — brings macros and functional patterns to the Lua ecosystem with zero overhead.
- [Forth](https://devtools.directory/languages/forth/) — Stack-based, extensible language used in embedded systems, bootstrapping, and as the base of OpenFirmware.
- [Fortran](https://devtools.directory/languages/fortran/) — The first high-level programming language — still the dominant choice for high-performance scientific and numerical computing.
- [F#](https://devtools.directory/languages/fsharp/) — Functional-first language on .NET — concise, type-safe, and excellent for data transformation, financial modelling, and domain-driven design.
- [Gleam](https://devtools.directory/languages/gleam/) — Type-safe functional language on the BEAM VM — friendly syntax, no nulls, and runs alongside Erlang and Elixir.
- [Go](https://devtools.directory/languages/go/) — Statically typed, compiled language from Google — fast, simple, and built for concurrency.
- [Grain](https://devtools.directory/languages/grain/) — Functional language that compiles to WebAssembly — strongly typed with a focus on safety and web-first deployment.
- [Groovy](https://devtools.directory/languages/groovy/) — Dynamic JVM language with optional typing and Java interoperability — the language behind Gradle and Jenkins pipelines.
- [Hack](https://devtools.directory/languages/hack/) — Gradually typed PHP dialect from Meta — adds static typing, generics, and modern language features to PHP.
- [Haskell](https://devtools.directory/languages/haskell/) — Purely functional, lazily evaluated language with a powerful type system — influential in type theory, compilers, and financial systems.
- [HCL](https://devtools.directory/languages/hcl/) — HashiCorp Configuration Language — the declarative language behind Terraform for defining cloud infrastructure as code.
- [Idris](https://devtools.directory/languages/idris/) — Dependently typed functional language — types can express arbitrary program properties, enabling proof-carrying code.
- [Io](https://devtools.directory/languages/io/) — Prototype-based, purely message-passing language — minimal syntax, everything is a message send to an object.
- [J](https://devtools.directory/languages/j/) — APL successor from Kenneth Iverson using ASCII symbols — array-oriented and extraordinarily expressive for mathematical computing.
- [Janet](https://devtools.directory/languages/janet/) — Lightweight Lisp/Clojure-inspired language designed for embedding and scripting — a single C file, no external dependencies.
- [Java](https://devtools.directory/languages/java/) — Object-oriented, write-once-run-anywhere language powering enterprise backends, Android, and big data.
- [JavaScript](https://devtools.directory/languages/javascript/) — The language of the web — runs in every browser and on the server via Node.js.
- [Julia](https://devtools.directory/languages/julia/) — High-performance dynamic language for scientific computing — designed to be as fast as C and as easy as Python.
- [Koka](https://devtools.directory/languages/koka/) — Research language from Microsoft that tracks side effects in the type system using algebraic effects and handlers.
- [Kotlin](https://devtools.directory/languages/kotlin/) — JVM language from JetBrains — concise, null-safe, and the preferred language for Android development.
- [Lean](https://devtools.directory/languages/lean/) — Interactive theorem prover and functional programming language — increasingly popular for formalising mathematics.
- [Lobster](https://devtools.directory/languages/lobster/) — Statically typed game scripting language with flow-sensitive typing and lifetime analysis — designed for safe, fast game logic.
- [Lua](https://devtools.directory/languages/lua/) — Lightweight, embeddable scripting language — the go-to choice for game engines, config systems, and plugin runtimes.
- [MATLAB](https://devtools.directory/languages/matlab/) — Numeric computing environment and language from MathWorks — the standard in engineering, signal processing, and scientific simulation.
- [Mercury](https://devtools.directory/languages/mercury/) — Logic/functional language with a static type and mode system — Prolog with the performance and safety guarantees of a compiled language.
- [Modula-2](https://devtools.directory/languages/modula2/) — Pascal successor by Niklaus Wirth — introduced the module system concept that influenced Ada, Java, and modern module systems.
- [Mojo](https://devtools.directory/languages/mojo/) — Python superset from Modular designed for AI — combines Python's ecosystem with systems-level performance via MLIR.
- [Nim](https://devtools.directory/languages/nim/) — Statically typed, compiled language with Python-like syntax — efficient as C, expressive as Python, with powerful metaprogramming via macros.
- [Nix](https://devtools.directory/languages/nix/) — Purely functional configuration language for the Nix package manager — enables reproducible builds and declarative system configuration.
- [Objective-C](https://devtools.directory/languages/objective-c/) — Smalltalk-style messaging layered on top of C — Apple's primary language for iOS and macOS before Swift.
- [OCaml](https://devtools.directory/languages/ocaml/) — Functional language with a powerful type system and optional mutability — used in compilers, proof assistants, and financial systems.
- [Odin](https://devtools.directory/languages/odin/) — Systems language designed as a clean alternative to C — fast, simple, no hidden allocations, with excellent tooling.
- [Pascal](https://devtools.directory/languages/pascal/) — Structured programming language designed for teaching — influenced Delphi, Modula-2, and a generation of programmers.
- [Perl](https://devtools.directory/languages/perl/) — Pragmatic text-processing language with powerful regex support — once the dominant language for CGI web programming and system administration.
- [PHP](https://devtools.directory/languages/php/) — Server-side scripting language powering a huge portion of the web, including WordPress and Laravel.
- [Pony](https://devtools.directory/languages/pony/) — Actor-based object-oriented language with a capability-security type system — data-race free and deadlock free by design.
- [PowerShell](https://devtools.directory/languages/powershell/) — Object-oriented shell and scripting language from Microsoft — the standard for Windows automation and cross-platform DevOps.
- [Prolog](https://devtools.directory/languages/prolog/) — Logic programming language — programs are expressed as facts and rules, and execution is driven by backtracking search.
- [PureScript](https://devtools.directory/languages/purescript/) — Strongly typed functional language that compiles to JavaScript — Haskell-inspired, with a focus on correctness.
- [Python](https://devtools.directory/languages/python/) — Readable, batteries-included language dominant in data science, AI, and web backends.
- [R](https://devtools.directory/languages/r/) — Statistical computing language and environment — the standard for data analysis, visualisation, and bioinformatics.
- [Racket](https://devtools.directory/languages/racket/) — Language-oriented programming platform descended from Scheme — used to teach programming and build new languages.
- [Rebol](https://devtools.directory/languages/rebol/) — Messaging language with a homoiconic, dialect-based approach — code and data share the same representation.
- [ReScript](https://devtools.directory/languages/rescript/) — Typed language with OCaml semantics that compiles to readable JavaScript — formerly BuckleScript/Reason.
- [REXX](https://devtools.directory/languages/rexx/) — Scripting language from IBM designed to be easy to learn — widely used on IBM mainframes and still the shell language of z/OS.
- [Roc](https://devtools.directory/languages/roc/) — Fast, friendly functional language with no runtime exceptions — statically typed with algebraic effects and a focus on developer experience.
- [Ruby](https://devtools.directory/languages/ruby/) — Elegant, developer-friendly scripting language known for Rails and a philosophy that optimises for programmer happiness.
- [Rust](https://devtools.directory/languages/rust/) — Systems programming language focused on memory safety and performance without a garbage collector.
- [SAS](https://devtools.directory/languages/sas/) — Statistical analysis software and language — dominant in clinical trials, pharmaceuticals, and regulated industries.
- [Scala](https://devtools.directory/languages/scala/) — Hybrid functional-OOP language on the JVM — the language of Apache Spark and large-scale data engineering.
- [Scheme](https://devtools.directory/languages/scheme/) — Minimalist Lisp dialect — the language of SICP and the foundation of many teaching and research languages.
- [Self](https://devtools.directory/languages/self/) — Prototype-based object-oriented language that pioneered JIT compilation and influenced JavaScript's prototype model.
- [Simula](https://devtools.directory/languages/simula/) — The world's first object-oriented language — introduced classes, objects, and inheritance in 1967.
- [Smalltalk](https://devtools.directory/languages/smalltalk/) — The original object-oriented language — everything is an object, and computation happens through message passing.
- [Solidity](https://devtools.directory/languages/solidity/) — Contract-oriented language for writing Ethereum smart contracts — the primary language of decentralised finance.
- [SQL](https://devtools.directory/languages/sql/) — Declarative query language for relational databases — the universal language for structured data retrieval and manipulation.
- [Squirrel](https://devtools.directory/languages/squirrel/) — Lightweight scripting language designed for embedding in games — used in Left 4 Dead, Portal 2, and Source engine games.
- [Standard ML](https://devtools.directory/languages/standard-ml/) — The original ML — a statically typed functional language influential in type theory, compilers, and programming language research.
- [Swift](https://devtools.directory/languages/swift/) — Apple's fast, safe language for iOS, macOS, and server-side development — designed to replace Objective-C.
- [Tcl](https://devtools.directory/languages/tcl/) — Dynamic scripting language with an everything-is-a-string philosophy — the scripting backbone of EDA tools and embedded interpreters.
- [TypeScript](https://devtools.directory/languages/typescript/) — JavaScript with static types — catches errors at compile time and scales to large codebases.
- [Unison](https://devtools.directory/languages/unison/) — Functional language where code is content-addressed — functions are identified by hash, enabling distributed computing and fearless refactoring.
- [V](https://devtools.directory/languages/v/) — Simple, fast compiled language inspired by Go — designed for rapid compilation and safe memory management without a GC.
- [Vale](https://devtools.directory/languages/vale/) — Fast, safe systems language using generational references instead of a borrow checker — aims for Rust-level safety with simpler ergonomics.
- [VBA](https://devtools.directory/languages/vba/) — Visual Basic for Applications — Microsoft Office's embedded language for automating Excel, Word, and Access.
- [Verilog](https://devtools.directory/languages/verilog/) — Hardware description language for designing and simulating digital circuits — the standard for ASIC and FPGA development.
- [VHDL](https://devtools.directory/languages/vhdl/) — IEEE-standardised hardware description language — the dominant choice for military and aerospace FPGA design.
- [Visual Basic](https://devtools.directory/languages/visual-basic/) — Microsoft's event-driven RAD language — introduced millions of developers to Windows programming in the 1990s and 2000s.
- [Wren](https://devtools.directory/languages/wren/) — Small, fast scripting language designed for embedding — class-based with a clean syntax and a single-file implementation.
- [Zig](https://devtools.directory/languages/zig/) — Modern systems language aiming to replace C — explicit, no hidden allocations, and with a powerful compile-time metaprogramming model.


## Frameworks (70 entries)

- [Actix Web](https://devtools.directory/frameworks/actix-web/) — Powerful, high-performance Rust web framework — async-first, type-safe extractors, and consistently ranked among the world's fastest web servers.
- [Angular](https://devtools.directory/frameworks/angular/) — Full-featured TypeScript framework from Google — opinionated, batteries-included, built for large-scale enterprise SPAs.
- [ASP.NET Core](https://devtools.directory/frameworks/aspnet-core/) — Cross-platform, high-performance web framework from Microsoft — REST APIs, MVC, Razor Pages, and real-time with SignalR.
- [Astro](https://devtools.directory/frameworks/astro/) — Content-focused web framework with islands architecture — ships zero JavaScript by default, integrates any UI framework.
- [Axum](https://devtools.directory/frameworks/axum/) — Ergonomic Rust web framework from the Tokio team — macro-free routing, extractors, and seamless Tower middleware compatibility.
- [Blazor](https://devtools.directory/frameworks/blazor/) — C# UI framework for the web — run .NET code in the browser via WebAssembly or server-side with SignalR.
- [Bootstrap](https://devtools.directory/frameworks/bootstrap/) — Responsive CSS component framework — grid system, pre-built components, and the web's most widely used frontend toolkit.
- [Celery](https://devtools.directory/frameworks/celery/) — Distributed task queue for Python — async background jobs, scheduled tasks, and workflows with Redis or RabbitMQ.
- [Chi](https://devtools.directory/frameworks/chi/) — Lightweight, idiomatic Go router — composable middleware, 100% net/http compatibility, zero external dependencies.
- [CodeIgniter](https://devtools.directory/frameworks/codeigniter/) — Lightweight PHP framework with a small footprint — fast to set up, minimal configuration, popular for hosting-constrained environments.
- [Cypress](https://devtools.directory/frameworks/cypress/) — End-to-end and component testing framework for web apps — runs in-browser with real-time reloading and a time-travel debugger.
- [Django](https://devtools.directory/frameworks/django/) — Batteries-included Python web framework — ORM, admin panel, auth, and routing out of the box.
- [Echo](https://devtools.directory/frameworks/echo/) — High-performance, extensible Go web framework — minimalist API with automatic TLS, WebSocket support, and data binding.
- [Electron](https://devtools.directory/frameworks/electron/) — Build cross-platform desktop apps with JavaScript, HTML, and CSS — powers VS Code, Slack, Figma, and thousands of other apps.
- [Expo](https://devtools.directory/frameworks/expo/) — React Native framework and platform — managed workflow, EAS Build, and over-the-air updates for cross-platform mobile apps.
- [Express](https://devtools.directory/frameworks/express/) — Minimal, unopinionated Node.js web framework — the backbone of most Node.js APIs and servers.
- [FastAPI](https://devtools.directory/frameworks/fastapi/) — Modern, async Python web framework with automatic OpenAPI docs and Pydantic-powered type validation.
- [Fastify](https://devtools.directory/frameworks/fastify/) — High-performance Node.js web framework — schema-based validation, plugin architecture, and up to 2x the throughput of Express.
- [Fiber](https://devtools.directory/frameworks/fiber/) — Express-inspired Go framework built on top of Fasthttp — the fastest Go web framework with a Node.js-like API.
- [Flask](https://devtools.directory/frameworks/flask/) — Lightweight Python web micro-framework — minimal core, WSGI-based, and highly extensible via blueprints and extensions.
- [Flutter](https://devtools.directory/frameworks/flutter/) — Google's UI toolkit for building natively compiled apps for mobile, web, and desktop from a single Dart codebase.
- [Gatsby](https://devtools.directory/frameworks/gatsby/) — React-based static site generator with a GraphQL data layer — pioneered the JAMstack approach for content-heavy websites.
- [Gin](https://devtools.directory/frameworks/gin/) — Fast, lightweight HTTP web framework for Go — radix tree router, middleware support, and idiomatic Go API.
- [Hibernate](https://devtools.directory/frameworks/hibernate/) — Java ORM framework — maps Java objects to relational database tables with HQL, caching, and lazy loading.
- [Hono](https://devtools.directory/frameworks/hono/) — Ultrafast web framework for the edge — runs on Cloudflare Workers, Deno, Bun, Node.js, and AWS Lambda with zero dependencies.
- [Ionic](https://devtools.directory/frameworks/ionic/) — Cross-platform mobile framework using web technologies — Angular, React, or Vue components rendered in a native WebView.
- [Jest](https://devtools.directory/frameworks/jest/) — Delightful JavaScript testing framework from Meta — zero config, snapshot testing, mocking, and code coverage built in.
- [Jetpack Compose](https://devtools.directory/frameworks/jetpack-compose/) — Android's modern declarative UI toolkit — Kotlin-first, composable functions replacing XML layouts.
- [JUnit](https://devtools.directory/frameworks/junit/) — The standard unit testing framework for Java — annotations, assertions, parameterised tests, and a rich extension model.
- [Keras](https://devtools.directory/frameworks/keras/) — High-level deep learning API — simple model building with backends for TensorFlow, PyTorch, and JAX.
- [Koa](https://devtools.directory/frameworks/koa/) — Next-generation Node.js web framework from the Express team — async/await middleware pipeline, minimal core.
- [Ktor](https://devtools.directory/frameworks/ktor/) — Async Kotlin framework from JetBrains — coroutine-native, multiplatform, for both server-side and client HTTP.
- [LangChain](https://devtools.directory/frameworks/langchain/) — Framework for building LLM-powered applications — chains, agents, retrieval-augmented generation, and tool use.
- [Laravel](https://devtools.directory/frameworks/laravel/) — Elegant PHP web framework with expressive syntax, an ORM, queue system, and rich ecosystem.
- [Micronaut](https://devtools.directory/frameworks/micronaut/) — JVM microservices framework with compile-time dependency injection — no reflection, fast startup, and low memory.
- [Mocha](https://devtools.directory/frameworks/mocha/) — Flexible JavaScript test runner — browser and Node.js support, unopinionated about assertions and mocking.
- [NestJS](https://devtools.directory/frameworks/nestjs/) — Progressive Node.js framework inspired by Angular — decorators, dependency injection, and modules for scalable server-side apps.
- [Next.js](https://devtools.directory/frameworks/nextjs/) — React framework with file-based routing, SSR, SSG, and API routes — the standard for production React apps.
- [NumPy](https://devtools.directory/frameworks/numpy/) — Fundamental array computing library for Python — the backbone of the entire scientific Python ecosystem.
- [Nuxt](https://devtools.directory/frameworks/nuxt/) — Full-stack Vue framework with SSR, file-based routing, and auto-imports — the standard way to build production Vue apps.
- [Pandas](https://devtools.directory/frameworks/pandas/) — Fast, flexible data analysis library — DataFrames, time series, and data wrangling for Python.
- [Phoenix](https://devtools.directory/frameworks/phoenix/) — Productive Elixir web framework — real-time channels, LiveView, and Rails-like conventions on the fault-tolerant BEAM VM.
- [Play Framework](https://devtools.directory/frameworks/play/) — Reactive web framework for Scala and Java — stateless, asynchronous, and built on Akka for high-throughput services.
- [Playwright](https://devtools.directory/frameworks/playwright/) — End-to-end browser testing framework from Microsoft — reliable, fast, and supports Chromium, Firefox, and WebKit.
- [Prisma](https://devtools.directory/frameworks/prisma/) — Next-generation TypeScript ORM — schema-first, auto-generated type-safe client, and Prisma Studio for data browsing.
- [pytest](https://devtools.directory/frameworks/pytest/) — The standard Python testing framework — simple assert statements, powerful fixtures, and a vast plugin ecosystem.
- [PyTorch](https://devtools.directory/frameworks/pytorch/) — Dynamic neural network framework from Meta — the dominant platform for ML research and increasingly for production.
- [Quarkus](https://devtools.directory/frameworks/quarkus/) — Kubernetes-native Java framework — fast startup, low memory footprint, native compilation via GraalVM.
- [Ruby on Rails](https://devtools.directory/frameworks/rails/) — Full-stack web framework that popularised convention over configuration — MVC, ActiveRecord ORM, and developer productivity by default.
- [React Native](https://devtools.directory/frameworks/react-native/) — Build native iOS and Android apps using React — bridge to native components, shared logic with web React codebases.
- [React](https://devtools.directory/frameworks/react/) — Declarative UI library from Meta for building component-based web interfaces.
- [Remix](https://devtools.directory/frameworks/remix/) — Full-stack React framework built on web standards — loaders, actions, and nested routing with progressive enhancement.
- [Rocket](https://devtools.directory/frameworks/rocket/) — Web framework for Rust focused on developer experience — type-checked routes, request guards, and zero-boilerplate handlers.
- [RSpec](https://devtools.directory/frameworks/rspec/) — Behaviour-driven development testing framework for Ruby — readable `describe/it/expect` DSL and the standard for Rails testing.
- [scikit-learn](https://devtools.directory/frameworks/scikit-learn/) — The standard Python machine learning library — consistent API for classification, regression, clustering, and preprocessing.
- [Sinatra](https://devtools.directory/frameworks/sinatra/) — Minimal Ruby DSL for building web applications — route definitions in a handful of lines, no MVC overhead.
- [Slim](https://devtools.directory/frameworks/slim/) — Micro-framework for PHP APIs and web apps — PSR-7 middleware stack, fast routing, and minimal overhead.
- [Solid](https://devtools.directory/frameworks/solid/) — Fine-grained reactive UI library — no virtual DOM, JSX compiled to real DOM operations, with React-like ergonomics.
- [Spring Boot](https://devtools.directory/frameworks/spring-boot/) — Opinionated Spring framework for production-ready Java microservices — auto-configuration, embedded servers, and a vast ecosystem.
- [SQLAlchemy](https://devtools.directory/frameworks/sqlalchemy/) — Python SQL toolkit and ORM — both low-level SQL expression language and high-level ORM, the standard for Python database access.
- [Starlette](https://devtools.directory/frameworks/starlette/) — Lightweight ASGI framework and toolkit — the foundation that FastAPI and other async Python frameworks are built on.
- [Svelte](https://devtools.directory/frameworks/svelte/) — Compiler-based UI framework — no virtual DOM, components compile to vanilla JS for minimal bundle size and maximum performance.
- [SvelteKit](https://devtools.directory/frameworks/sveltekit/) — Full-stack Svelte framework with SSR, file-based routing, and edge-ready deployment — the official way to build Svelte apps.
- [SwiftUI](https://devtools.directory/frameworks/swiftui/) — Apple's declarative UI framework — build native apps for iOS, macOS, watchOS, and tvOS with a single Swift codebase.
- [Symfony](https://devtools.directory/frameworks/symfony/) — Enterprise-grade PHP framework — reusable components powering Laravel, Drupal, Magento, and countless other PHP projects.
- [Tailwind CSS](https://devtools.directory/frameworks/tailwindcss/) — Utility-first CSS framework — compose designs directly in markup with small, single-purpose classes.
- [Tauri](https://devtools.directory/frameworks/tauri/) — Build tiny, fast desktop apps with a Rust core and any web frontend — 10x smaller bundles than Electron with lower memory usage.
- [TensorFlow](https://devtools.directory/frameworks/tensorflow/) — End-to-end open-source ML platform from Google — model building, training, deployment across CPU, GPU, TPU, and mobile.
- [Vert.x](https://devtools.directory/frameworks/vert-x/) — Reactive toolkit for building event-driven applications on the JVM — polyglot, non-blocking, and massively scalable.
- [Vue](https://devtools.directory/frameworks/vue/) — Progressive JavaScript framework for building UIs — approachable, flexible, and incrementally adoptable.


## Full content

For full metadata on all entries, see: https://devtools.directory/llms-full.txt
For machine-readable JSON index: https://devtools.directory/index.json