Every course.
One place.
235 courses · 2,477 curated resources across languages, principles, patterns, tools, AI, and more. Pick a category — or just see everything.
Browse by topic
Categories
Courses & hubs
Languages
Ada
Ada is a high-integrity, statically-typed programming language designed for safety-critical and real-time systems. It is used extensively in aerospace, defense, railway, and medical systems where reliability is paramount.
Assembly
Assembly language provides direct control over CPU instructions, memory, and registers. Essential for understanding computer architecture, reverse engineering, embedded systems, and performance-critical code optimization.
AutoHotkey
AutoHotkey is a free, open-source scripting language for Windows desktop automation. It enables creating hotkeys, macros, form fillers, and custom UI tools to automate repetitive tasks.
Bash
GNU replacement for the Bourne shell
C
C is the foundational systems programming language that powers operating systems, embedded devices, databases, and virtually every major software infrastructure. These are the definitive free resources — vetted, current, and complete.
Clojure
Clojure is a modern, functional Lisp dialect on the JVM. It emphasizes immutability, persistent data structures, and concurrency, with powerful macro capabilities for metaprogramming.
COBOL
COBOL (Common Business-Oriented Language) powers the worlds business infrastructure — banking systems, insurance claims, government systems, and enterprise transaction processing. Billions of lines of COBOL still run in production today.
Common Lisp
Common Lisp is a multi-paradigm programming language known for its powerful macro system, dynamic typing, and interactive development cycle. It excels at AI, symbolic computing, and meta-programming.
C++
C++ is a systems programming language that gives you complete control over memory and hardware. It powers game engines, browsers (Chrome), operating systems, embedded devices, and high-frequency trading. These are the definitive free resources — vetted, current, and complete.
Crystal
Crystal is a statically typed, compiled language with Ruby-like syntax but blazing performance via LLVM. It excels at web applications, backend services, and systems programming with type inference and nil safety.
C#
C# is Microsofts flagship language for the .NET ecosystem. It powers Windows applications, game development (Unity), cloud services on Azure, and cross-platform apps. These are the definitive free resources — vetted, current, and complete.
D
D is a systems programming language combining C-level performance with modern convenience. It offers garbage collection, manual memory management, compile-time function execution, and a powerful template system.
Dart
Dart is the language behind Flutter, Googles cross-platform UI framework. It is optimized for building fast mobile, web, and desktop apps with a single codebase. These are the definitive free resources — vetted, current, and complete.
Elixir
Elixir is a functional, concurrent language built on the Erlang VM (BEAM). It excels at building fault-tolerant, distributed systems with the Phoenix web framework and LiveView for real-time apps. These are the definitive free resources — vetted, current, and complete.
Elm
Elm is a delightful functional language for building reliable web applications. It offers zero runtime exceptions, an advanced type system, and a practical approach to frontend development with its signature architecture.
Erlang
Erlang is a functional, concurrent language designed for building massively scalable, fault-tolerant systems with soft real-time properties. It powers telecommunications, messaging platforms (WhatsApp), and distributed databases.
Fortran
Fortran is the original high-performance computing language, still dominant in scientific computing, weather simulation, computational physics, and numerical weather prediction. Modern Fortran (2008/2018) brings coarrays and OOP.
F#
F# is a functional-first, cross-platform .NET language. It excels at data science, financial modeling, and concurrent systems with type providers, computation expressions, and seamless .NET interop.
GDScript
GDScript is the primary scripting language for the Godot Engine. It has a Python-like syntax but is optimized for game development with built-in types like vectors, colors, and nodes.
Gleam
Gleam is a friendly, statically-typed functional language that compiles to Erlang (BEAM). It offers a modern Rust-inspired type system, actor-based concurrency, and seamless interop with the BEAM ecosystem.
Go
Go is a statically typed, compiled language designed at Google for building simple, reliable, and efficient software at scale. It excels at backend services, microservices, APIs, and concurrent systems.
Groovy
Apache Groovy is a powerful, optionally typed, dynamic language for the JVM. It integrates seamlessly with Java and powers Gradle builds, Jenkins pipelines, and modern DSLs with concise syntax and metaprogramming capabilities.
Haskell
Haskell is a purely functional programming language with strong static typing and lazy evaluation. It provides an unparalleled foundation for writing correct, composable, and concurrent software. These are the definitive free resources — vetted, current, and complete.
Haxe
Haxe is a cross-platform language and toolkit that compiles to JavaScript, C++, Python, Lua, PHP, Java, and more. It is ideal for building applications that need to run on multiple platforms from a single codebase.
Java
Java is the bedrock of enterprise software. It powers Android apps, backend systems, big data pipelines (Apache Hadoop, Spark), and financial infrastructure worldwide. These are the definitive free resources — vetted, current, and complete.
JavaScript
The language of the web. JavaScript powers browsers, servers (Node.js), desktop apps (Electron), and increasingly the edge. These are the definitive free resources — vetted, current, and complete.
Julia
Julia is a high-performance, dynamically typed language designed for scientific computing, numerical analysis, and machine learning. It combines the speed of C with the ease of Python.
Kotlin
Kotlin is the modern JVM language that is now the primary language for Android development. It is concise, expressive, and fully interoperable with Java. These are the definitive free resources — vetted, current, and complete.
LabVIEW
LabVIEW (Laboratory Virtual Instrument Engineering Workbench) is a graphical programming platform from NI used extensively in test, measurement, and control applications across engineering and science.
Lua
Lua is a lightweight, embeddable scripting language prized for its speed, simplicity, and tiny footprint. It powers game engines (Roblox, Love2D), embedded systems, and configuration in Neovim and Redis. These are the definitive free resources — vetted, current, and complete.
MATLAB
MATLAB is the premier platform for numerical computing, data analysis, and algorithm development. It is widely used in engineering, science, and research for matrix operations, signal processing, and control systems.
Nim
Nim is an efficient, statically typed systems programming language with Python-like syntax. It compiles to C via its compiler, offering C-level performance with high-level expressiveness and metaprogramming.
OCaml
OCaml is a functional, imperative, and object-oriented language from the ML family. It excels at type-safe systems programming, formal verification, and high-assurance software with a powerful module system and type inference.
Perl
Perl is a highly capable, feature-rich programming language known for its text processing power, CPAN module ecosystem, and versatility in system administration, web development, and bioinformatics.
PHP
PHP powers over 75% of all websites, including WordPress, Laravel applications, and massive platforms like Facebook. It is the most accessible backend language with an unmatched ecosystem. These are the definitive free resources — vetted, current, and complete.
Prolog
Prolog is a logic programming language associated with artificial intelligence, computational linguistics, and symbolic reasoning. It uses declarative programming where you describe problem constraints and let the engine find solutions.
PureScript
PureScript is a strongly-typed, purely functional programming language that compiles to JavaScript. It features algebraic data types, type classes, and a sophisticated type system inspired by Haskell, making it ideal for building reliable web applications.
Python
The most versatile language in the ecosystem. Python powers data science, machine learning, backend systems, automation, and scripting. These are the definitive free resources — vetted, current, and complete.
R
R is the definitive language for statistical computing, data analysis, and visualization. It powers academic research, data science, and machine learning workflows worldwide. These are the definitive free resources — vetted, current, and complete.
Racket
Racket is a modern functional and general-purpose programming language in the Lisp/Scheme family. It excels at language-oriented programming, creating domain-specific languages, and teaching computer science fundamentals.
Ruby
Ruby is a language of simplicity and productivity, famous for the Rails web framework. It prioritizes developer happiness and elegant code with a philosophy of convention over configuration. These are the definitive free resources — vetted, current, and complete.
Rust
Rust is a systems programming language focused on safety, speed, and concurrency without a garbage collector. It powers everything from embedded devices to cloud infrastructure.
Scala
Scala combines object-oriented and functional programming on the JVM. It powers high-performance data pipelines (Apache Spark), distributed systems (Akka), and type-safe web applications. These are the definitive free resources — vetted, current, and complete.
Scheme
Scheme is a minimalist, elegant dialect of Lisp renowned for its simplicity and use in computer science education. It features lexical scoping, first-class procedures, and a unified syntax that makes it ideal for teaching programming fundamentals.
Scratch
Scratch is the worlds largest coding community for children and the best way to start programming. It teaches computational thinking through a visual block-based interface used by millions worldwide.
Shell
Shell scripting (Bash) is the universal glue of software engineering. It automates deployments, manages infrastructure, processes data pipelines, and controls the entire development toolchain. These are the definitive free resources — vetted, current, and complete.
Solidity
Solidity is the primary programming language for writing smart contracts on Ethereum and EVM-compatible blockchains. It enables decentralized applications, DeFi protocols, and NFTs — the backbone of Web3.
Swift
Swift is the modern language for Apple platforms — iOS, macOS, watchOS, and tvOS. It is fast, safe, and expressive, powering everything from the iPhone apps you love to server-side systems. These are the definitive free resources — vetted, current, and complete.
TypeScript
TypeScript is JavaScript with static types. It catches errors at compile time, enables fearless refactoring, and powers the largest codebases in the world. These are the definitive free resources — vetted, current, and complete.
V
V is a simple, fast, safe, compiled language for developing maintainable software. It offers C interop, a built-in GUI library, cross-platform compilation, and a focus on simplicity with a small language specification.
WebAssembly
WebAssembly (Wasm) is a low-level binary instruction format that runs at near-native speed in browsers and beyond. It enables compiling C/C++, Rust, Go, and other languages to run on the web and in edge runtimes.
Wolfram Language
Wolfram Language is a multi-paradigm computational language developed by Wolfram Research. It powers Mathematica and excels at symbolic mathematics, data science, machine learning, and knowledge-based computing.
Zig
Zig is a modern systems programming language focused on robustness, optimality, and maintainability. It offers manual memory management, compile-time computation, seamless C interop, and a first-class cross-compilation toolchain.
Courses & hubs
System Design
Building Blocks
The infrastructure primitives you combine to build real systems — load balancers, caching, queues, databases, CDNs.
Design Patterns
Proven architectural patterns for common distributed-systems problems — consistent hashing, CQRS, circuit breakers, gateways.
Fundamentals
Core concepts every engineer must understand before designing systems — scalability, availability, and estimation.
Interview Prep
Frameworks, common questions, and trade-off analysis for system design interviews.
Courses & hubs
Case Studies
Amazon Shopping Cart
How Amazon handles flash sales, DynamoDB, and Prime Day traffic spikes with microservices and chaos engineering.
Discord Real-Time Communication
How Discord handles 19M+ servers and trillions of messages using Elixir, ScyllaDB, and custom C++ voice infrastructure.
Google Search
How Google handles 8.5B searches/day with Caffeine indexing, PageRank, and distributed infrastructure like Spanner and BigTable.
Netflix Video Streaming
How Netflix delivers content to 250M+ subscribers using Open Connect CDN, chaos engineering, and 500+ microservices.
TikTok Video Delivery
How TikTok's AI-powered recommendation engine and video pipeline serve 1B+ users with personalized content.
Twitter/X News Feed
How Twitter delivers 500M+ tweets/day to hundreds of millions of users using hybrid fan-out strategies.
Uber Ride Matching
How Uber matches riders to drivers in real-time using H3 geospatial indexing, surge pricing, and event-driven architecture.
WhatsApp Real-Time Messaging
How WhatsApp delivers 100B+ messages/day to 2B+ users with only ~50 engineers using Erlang and XMPP.
Courses & hubs
AI
AI Agents
Design agents that reason, use tools and act: agent loops, tool use, memory, planning, multi-agent systems and agent frameworks.
AI Safety
Understand the risks of AI systems and the practices that keep them aligned, robust and fair — from evals to governance.
Computer Vision
From pixels to perception: image processing, CNNs, detection, segmentation, pose, tracking, OCR and vision transformers.
Data Science
From statistics and pandas to end-to-end projects — the complete foundation for turning raw data into decisions.
Deep Learning
Neural networks end to end: backprop, PyTorch, CNNs, RNNs, LSTMs and transformers — from perceptron to attention.
Generative AI
Generative AI end to end: LLMs, prompting, fine-tuning, RAG, agents, diffusion, VLMs and running GenAI in production.
LLM Engineering
Build with large language models: tokenization, embeddings, RAG, fine-tuning, evals, agents and production LLM systems.
Machine Learning
Supervised and unsupervised learning with scikit-learn: regression, trees, ensembles, SVMs, clustering and the math underneath.
MLOps
Operationalize machine learning: lifecycle, versioning, pipelines, experiment tracking, serving, Kubernetes and drift monitoring.
NLP
Natural language processing: tokenization, embeddings, classification, NER, sequence models, BERT and transformers.
Prompt Engineering
Get the best out of language models: system prompts, few-shot, chain-of-thought, structured outputs, and evaluation.
Reinforcement Learning
From MDPs and dynamic programming to DQN, PPO and multi-agent systems — the complete guide to agents that learn from outcomes.
Courses & hubs
Principles
ACID
A set of database transaction properties: Atomicity, Consistency, Isolation, Durability. Guarantees reliable processing of database transactions.
Backpressure
A mechanism that allows a consumer to signal to a producer that it cannot keep up. Prevents systems from being overwhelmed by controlling data flow.
BASE
A consistency model used in distributed systems: Basically Available, Soft State, Eventual Consistency. Contrasts with ACID for highly available, partition-tolerant systems.
Bulkhead
Isolate components into separate pools so that a failure in one does not cascade to others. Prevents resource exhaustion from affecting the entire system.
Caching
Store frequently accessed data in a high-speed storage layer to reduce latency and load on backend systems. A fundamental performance optimization pattern.
CAP Theorem
In a distributed system, you can only guarantee two out of three: Consistency, Availability, and Partition Tolerance. A fundamental trade-off in distributed data stores.
Circuit Breaker
Prevents repeated attempts to call a failing service by opening the circuit and failing fast. Allows the system to recover by periodically testing the service.
Consistency Patterns
Strategies for managing data consistency in distributed systems: strong consistency, eventual consistency, and causal consistency. Each offers different trade-offs.
Convention over Configuration
Reduce the number of decisions developers need to make by providing sensible defaults. Frameworks like Rails and Spring use this to simplify setup.
Command-Query Separation
Every method should be either a command that performs an action or a query that returns data, but not both. Improves clarity and predictability of code.
Defensive Programming
Design code to handle unexpected inputs and states gracefully. Assume inputs will be invalid and protect against potential errors preemptively.
Dependency Inversion
Depend upon abstractions, not concretions. High-level modules should not depend on low-level modules; both should depend on abstractions.
DRY (Don't Repeat Yourself)
Every piece of knowledge must have a single, unambiguous, authoritative representation within a system. Eliminates duplication to reduce maintenance costs.
Eventual Consistency
A consistency model where updates propagate to all nodes eventually, but not immediately. Provides high availability at the cost of temporary inconsistency.
Fail-Fast
Report errors immediately and halt execution when an unexpected condition occurs. Prevents cascading failures and makes bugs easier to detect.
Graceful Degradation
When part of a system fails, the system continues to operate at a reduced capacity rather than failing completely. Essential for resilient distributed systems.
Idempotency
An operation that can be applied multiple times without changing the result beyond the first application. Critical for safe retries in distributed systems.
Information Hiding
Hide internal implementation details of a module from its consumers. Expose only what is necessary through a well-defined interface.
Interface Segregation
No client should be forced to depend on methods it does not use. Prefer small, focused interfaces over large, general-purpose ones.
KISS (Keep It Simple, Stupid)
Systems work best when they are kept simple rather than made complex. Avoid unnecessary complexity in design and implementation.
Leader Election
A distributed algorithm for selecting a single node as the coordinator among a group of nodes. Essential for consensus and coordination in distributed systems.
Liskov Substitution
Objects of a superclass should be replaceable with objects of its subclasses without breaking the system. Subtypes must be substitutable for their base types.
Load Shedding
Drops lower-priority requests when the system is under heavy load to ensure critical requests are processed. A key resilience pattern for high-traffic services.
Open-Closed Principle
Software entities should be open for extension but closed for modification. Design modules that can be extended without modifying their source code.
Optimistic Locking
Assumes multiple transactions can complete without conflict and only checks for conflicts at commit time. Uses version numbers to detect stale updates.
Pessimistic Locking
Assumes conflicts will occur and locks data at the start of a transaction to prevent concurrent modifications. Ensures data integrity at the cost of throughput.
Principle of Least Privilege
Every program and user should operate with the minimum set of permissions necessary to complete their task. Reduces the attack surface and blast radius.
Quorum
A consensus mechanism requiring a minimum number of nodes to agree on a decision. Used in distributed systems for reads/writes and leader election.
Rate Limiting
Controls the rate of requests a service can process within a time window. Prevents resource exhaustion and ensures fair usage across clients.
Separation of Concerns
Divide a system into distinct sections where each section addresses a separate concern. Reduces complexity by modularizing functionality.
Single Responsibility
A class should have only one reason to change, meaning it should have only one job or responsibility. Promotes high cohesion and reduces coupling between components.
SOLID Principles
Five object-oriented design principles: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. The foundation of maintainable OOP.
Throttling
Slows down the processing of requests to prevent system overload. Often used with rate limiting to gracefully handle traffic spikes.
YAGNI (You Ain't Gonna Need It)
Always implement things when you actually need them, never when you merely foresee that you might need them. Prevents over-engineering and code bloat.
Courses & hubs
Patterns
Abstract Factory
Provides an interface for creating families of related or dependent objects without specifying their concrete classes. Used when a system needs to be independent of how its objects are created.
Adapter
Allows objects with incompatible interfaces to collaborate. Acts as a wrapper between two interfaces, converting the interface of a class into another interface clients expect.
Ambassador
Creates a helper service that handles cross-cutting concerns like retries, circuit breaking, and authentication on behalf of a client service.
B-Tree
A self-balancing tree data structure that maintains sorted data and enables efficient insertion, deletion, and search operations. The standard index structure in relational databases.
Bloom Filter
A space-efficient probabilistic data structure for testing whether an element is a member of a set. Can return false positives but never false negatives. Used in caching and spell checkers.
Bridge
Decouples an abstraction from its implementation so that the two can vary independently. Used when both the abstraction and implementation may have multiple variations.
Builder
Separates the construction of a complex object from its representation, allowing the same construction process to create different representations. Ideal for objects with many optional parameters.
Chain of Responsibility
Passes a request along a chain of handlers. Each handler decides either to process the request or pass it to the next handler in the chain.
Circuit Breaker
Prevents an application from repeatedly trying to execute an operation that is likely to fail. Opens the circuit to fail fast and allows recovery time for the downstream service.
Command
Encapsulates a request as an object, allowing parameterization of clients with queues, requests, and operations. Supports undoable operations and logging.
Composite
Composes objects into tree structures to represent part-whole hierarchies. Lets clients treat individual objects and compositions uniformly.
Consistent Hashing
A distributed hashing scheme that minimizes key redistribution when the number of nodes changes. Used by DynamoDB, Cassandra, and CDNs for data partitioning.
CQRS
Separates read and write operations into different models. Commands handle writes, queries handle reads — often with different data stores optimized for each purpose.
Decorator
Attaches additional responsibilities to an object dynamically. Provides a flexible alternative to subclassing for extending functionality.
Event Sourcing
Stores the state of a system as a sequence of events rather than the current state. Enables full auditability, time travel, and complex event processing.
Facade
Provides a unified interface to a set of interfaces in a subsystem. Defines a higher-level interface that makes the subsystem easier to use.
Factory Method
Defines an interface for creating an object, but lets subclasses decide which class to instantiate. Promotes loose coupling by deferring object creation to subclasses.
Fanout
Distributes incoming messages or tasks to multiple workers or queues for parallel processing. Widely used in data pipelines and event-driven architectures.
Flyweight
Uses sharing to support large numbers of fine-grained objects efficiently. Reduces memory usage by sharing common parts of state between multiple objects.
Gossip Protocol
A peer-to-peer communication protocol where nodes periodically exchange state information with random peers. Used for failure detection in distributed systems like Cassandra and Consul.
Hash Index
An index structure that uses a hash function to map keys to bucket locations. Provides O(1) lookup for equality queries but does not support range queries.
Interpreter
Given a language, defines a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
Iterator
Provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. Supports multiple traversals.
Leader-Follower
A thread coordination pattern where one thread (leader) waits for events while others (followers) process them. The leader promotes a follower upon receiving an event.
LRU Cache
Evicts the least recently used items when the cache reaches capacity. Combines a hash map for O(1) lookups with a doubly-linked list for efficient eviction tracking.
LSM Tree
A data structure optimized for write-heavy workloads. Maintains data in a series of immutable sorted files merged in the background. Used by LevelDB, RocksDB, and Cassandra.
MapReduce
A programming model for processing large datasets in parallel across distributed clusters. Consists of a Map step (filter/sort) and a Reduce step (summarize/aggregate).
Mediator
Defines an object that encapsulates how a set of objects interact. Promotes loose coupling by preventing objects from referring to each other explicitly.
Memento
Captures and externalizes an object's internal state so that the object can be restored to this state later. Supports undo and rollback operations.
Multi-Leader Replication
A database replication strategy where multiple nodes accept writes and replicate changes to each other. Useful for multi-datacenter deployments and offline-first applications.
MVC
Separates an application into three interconnected components: Model (data), View (UI), and Controller (business logic). The dominant pattern for web frameworks.
MVCC
Multi-Version Concurrency Control allows concurrent access to a database by keeping multiple versions of each data item. Readers see a consistent snapshot without blocking writers.
MVVM
Extends MVC by separating the View from its backing data using a ViewModel that exposes data and commands. Popular in modern UI frameworks like Angular, Vue, and WPF.
Observer
Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
Paxos
A consensus algorithm that enables a distributed system to agree on a single value despite failures. Foundational to distributed consensus and leader election.
Prototype
Creates new objects by copying an existing object, known as the prototype. Useful when object creation is expensive and you want to avoid subclasses.
Proxy
Provides a surrogate or placeholder for another object to control access to it. Useful for lazy loading, access control, logging, and caching.
Publish-Subscribe
A messaging pattern where senders (publishers) send messages without knowing the receivers (subscribers). Decouples components through a message broker.
Raft
A consensus algorithm designed to be more understandable than Paxos. Uses leader election and log replication to achieve consensus in distributed systems. Powers etcd and Consul.
Replication
The process of maintaining copies of data across multiple nodes. Provides fault tolerance, high availability, and improved read performance in distributed systems.
Repository
Mediates between the domain and data mapping layers, acting like an in-memory domain object collection. Centralizes data access logic and improves testability.
Retry Pattern
Enables an application to retry a failed operation in anticipation of transient failures. Often combined with exponential backoff and jitter to avoid overwhelming the downstream service.
Saga
Manages distributed transactions by breaking them into a sequence of local transactions with compensating actions for rollback. Essential for microservices.
Sharding
Partitions a large database into smaller, faster, more manageable parts called shards. Each shard holds a subset of data and can be managed independently.
Sidecar
Deploys auxiliary components (logging, monitoring, networking) as a separate container alongside the main application container. Common in service mesh architectures.
Singleton
Ensures a class has only one instance and provides a global point of access to it. Commonly used for logging, driver objects, caching, and thread pools.
State
Allows an object to alter its behavior when its internal state changes. The object will appear to change its class at runtime.
Strangler Fig
Incrementally replaces a legacy system by building a new system alongside it and gradually routing functionality from the old to the new, eventually decommissioning the old.
Strategy
Defines a family of algorithms, encapsulates each one, and makes them interchangeable. Lets the algorithm vary independently from clients that use it.
Template Method
Defines the skeleton of an algorithm in a method, deferring some steps to subclasses. Lets subclasses redefine certain steps without changing the algorithm's structure.
Two-Phase Commit
A distributed transaction protocol that ensures all participating nodes either commit or abort a transaction. Provides atomicity across multiple databases or services.
Visitor
Represents an operation to be performed on elements of an object structure. Lets you define a new operation without changing the classes of the elements.
Courses & hubs
Tools
Apache Airflow
Apache Airflow is the leading platform for programmatically authoring, scheduling, and monitoring workflows. It lets you build data pipelines as directed acyclic graphs (DAGs) with Python.
Angular
TypeScript-based web application framework by Google
Ansible
Automation tool for configuration management, application deployment, and task automation
Apache Flink
Stream processing framework for real-time data applications
Apache Spark
Unified analytics engine for large-scale data processing
AWS
Comprehensive cloud computing platform by Amazon
Babel
JavaScript compiler for transforming modern code into compatible versions
Content Delivery Network
Geographically distributed network of proxy servers and data centers
Chart.js
Chart.js is the most popular open-source JavaScript charting library. It provides beautiful, responsive, and interactive charts with a simple API for building data visualizations for the web.
Cloudflare
American technology company
Cypress
Cypress is a next-generation frontend testing framework built for the modern web. It enables fast, reliable end-to-end, component, and integration testing with real-time reloads and time-travel debugging.
Database
Organized collection of structured data with efficient retrieval and storage
Deno
Secure runtime for JavaScript and TypeScript by the creator of Node.js
Django
High-level Python web framework encouraging rapid development
Docker
Platform for developing, shipping, and running applications in containers
Elasticsearch
Distributed search and analytics engine built on Apache Lucene
Electron
Electron is a framework for building cross-platform desktop applications using JavaScript, HTML, and CSS. It combines Chromium and Node.js to enable web developers to create native desktop apps for Windows, macOS, and Linux.
Envoy
High-performance proxy designed for service mesh architectures
ESLint
ESLint is the most widely used JavaScript linting tool for identifying and fixing code quality issues. It provides a pluggable architecture with hundreds of rules for enforcing coding standards and catching bugs.
Expo
Expo is an open-source platform for building universal native apps with React. It provides a managed workflow, comprehensive SDK, and development tools for creating iOS, Android, and web applications from a single codebase.
Express.js
Minimal and flexible Node.js web application framework
Git
Distributed version control system for tracking source code changes
GitHub Actions
CI/CD platform for automating software workflows directly in GitHub repositories
GitLab
GitLab is a complete DevOps platform delivered as a single application. It provides Git repository management, CI/CD, security scanning, and monitoring throughout the entire development lifecycle.
Grafana
Observability and data visualization platform for metrics, logs, and traces
gRPC
High-performance remote procedure call framework by Google
Istio
Service mesh layer for managing microservice communication
Jenkins
Open-source automation server for continuous integration and delivery
Jest
Jest is the most popular JavaScript testing framework. Created by Meta, it provides a zero-config setup, built-in mocking, snapshot testing, and code coverage for projects of any size.
JWT
Proposed web cryptography standard
Apache Kafka
Distributed event streaming platform for high-throughput data pipelines
Kubernetes
Container orchestration platform for automating deployment, scaling, and management
Linux
Family of Unix-like operating systems that use the Linux kernel
LLVM
Compiler backend for multiple programming languages
MongoDB
Cross-platform document-oriented database
MySQL
Popular open-source relational database management system
Neovim
Neovim is a hyper-extensible, modern refactor of Vim. It features asynchronous architecture, built-in LSP client, Tree-sitter syntax engine, and first-class Lua support for creating powerful editor configurations.
Next.js
React framework for production-grade full-stack web applications
NGINX
Open source web server and a reverse proxy server
Node.js
JavaScript runtime environment
NoSQL
Non-relational database systems designed for scale and flexibility
OAuth
Open standard for token-based authentication and authorization
OpenTelemetry
Linux Foundation project
PostgreSQL
Advanced open-source relational database with strong ACID compliance
Prettier
Prettier is an opinionated code formatter that supports many languages. It enforces consistent style by parsing code and reprinting it with its own rules, eliminating debates about code formatting.
Processing
Processing is a flexible software sketchbook and language for learning how to code within the context of the visual arts. It is the premier tool for creative coding, generative art, and data visualization.
Prometheus
Monitoring and alerting toolkit for cloud-native environments
Protocol Buffers
Google's language-neutral serialization format for structured data
RabbitMQ
Open-source message broker implementing AMQP protocol
Ruby on Rails
Server-side web application framework written in Ruby
React
JavaScript library for building user interfaces
Redis
In-memory data structure store used as cache, database, and message broker
Redis Cache
In-memory caching layer commonly built on Redis for high-speed data access
Relational Database
Database organized according to the relational model of data
REST
Architectural style for designing networked applications
Selenium
Selenium is the most widely used browser automation framework. It supports multiple browsers and programming languages for web application testing, scraping, and automation at scale.
Socket.IO
Socket.IO is a real-time bidirectional event-based communication library. It enables real-time, bidirectional communication between web clients and servers using WebSocket with fallback options.
Spring Framework
Application framework and inversion of control container for Java
SQLite
Embedded SQL database engine known for simplicity and reliability
Svelte
Compiler-driven framework for building fast web applications
Terraform
Infrastructure as Code tool for defining and provisioning cloud resources
Three.js
Three.js is the most popular 3D JavaScript library for creating interactive 3D graphics in the browser using WebGL and WebGPU. It provides a comprehensive API for scenes, cameras, lights, materials, and animations.
TLS
Cryptographic protocol for secure communication over a network
TypeScript Compiler
Compiles TypeScript to JavaScript, performing type checking and transpilation
Varnish Cache
HTTP accelerator and reverse proxy for caching web content
Vercel
American cloud application company
Vite
Vite is a modern build tool that provides an extremely fast development server with native ES module imports and optimized production builds using Rollup. It is the default build tool for Vue, React, Svelte, and many other frameworks.
Vitest
Vitest is a blazing-fast unit test framework powered by Vite. It offers Jest-compatible API with native ESM support, TypeScript integration, and instant hot-module reloading for an exceptional testing experience.
Vue.js
Progressive JavaScript framework for building user interfaces
WebAssembly Runtime
Runtime engine for executing WebAssembly modules outside the browser
Webpack
Module bundler for JavaScript applications
WebSocket
Computer network protocol