Skip to content
Scrollchart
💻

Free Animated Computing Diagrams

Algorithms, data structures, networking, systems, databases, security, web. The diagrams every developer wants.

111 live For: Developer bloggers · Vendor docs · CS educators · DevOps/SRE · Security blogs

Developer audiences are pre-converted to embeds. Sort visualizers, BST rotations, BFS/DFS, Dijkstra, TCP/TLS handshakes, B-trees, GC cycles, cache hierarchy, hash collision resolution, OAuth flows, load balancers. All animated, all light, all linkable from any dev blog.

What this is
Free, embeddable, animated diagrams covering computing topics (algorithms, data structures, networking, systems, and more).
Who uses it
Developer bloggers · Vendor docs · CS educators · DevOps/SRE · Security blogs
How to embed
Copy one line of HTML per diagram. No signup. No watermark. Works in WordPress, Webflow, Ghost, Substack, plain HTML.
Diagrams in this category
111 live (total in catalog: 111).
License
Free forever. The diagram and editorial explainer text are served from scrollchart.com so they can be updated over time to reflect new research.
URL
scrollchart.com/categories/computing
Highlights

What you will find here

  • Algorithms: sorting, search, graph traversal, DP
  • Data structures: trees, heaps, hash tables
  • Networking: TCP, TLS, DNS, BGP, HTTP
  • Systems: cache, GC, scheduling, virtualization
  • Databases, security, web architecture
Sub-categories

7 topic areas in Computing

Algorithms

Sorting, searching, graph traversal, DP, greedy, divide-and-conquer.

22 live
Data structures

Trees, heaps, hash tables, tries, graphs, bloom filters.

15 live
Networking

TCP, TLS, DNS, BGP, HTTP/2, QUIC, NAT, CDN.

18 live
Systems

Cache hierarchy, GC, scheduling, virtual memory, syscalls.

16 live
Databases

B-trees, LSM trees, indexes, transactions, replication, sharding.

16 live
Security

OAuth, JWT, hashing, signatures, TLS handshake, threat models.

14 live
Web architecture

Load balancers, microservices, CDNs, edge compute, queues.

10 live
Catalog

Browse Computing diagrams

All categories →

Algorithms 22 live

Sorting, searching, graph traversal, DP, greedy, divide-and-conquer.

Computing Rich

Quicksort: Partition Animation

Pivot, two-pointer partition, recursive divide. Watch the array sort itself in O(n log n) average.
Computing Rich

Mergesort: Split and Merge

Recursively split to size 1, then merge sorted halves. Stable, predictable O(n log n).
Computing Rich

Dijkstra's Shortest Path

Greedy frontier expansion with a min-heap. Watch tentative distances tighten until every node is settled.
Computing Rich

A* Search with Heuristic

Dijkstra plus a heuristic that biases the frontier toward the goal. Guided, often dramatically faster.
Computing Simple

Bubblesort: Pass-by-Pass

Adjacent-swap passes bubble the largest element to the end each round. O(n^2) but visually obvious.
Computing Medium

Heapsort: Build Heap & Sift

Heapify in O(n), then repeatedly extract max and sift down. In-place O(n log n).
Computing Medium

Radix Sort: Digit Buckets

Sort by least-significant digit, then next, then next. Linear-time, integer-only.
Computing Simple

Binary Search

Halve the search range each comparison. log2(n) steps to find any element in a sorted array.
Computing Medium

BFS: Layer-by-Layer Traversal

A queue expands outward from the source. Shortest hops, level by level.
Computing Medium

DFS: Stack-Based Deep Dive

A stack drives one branch deep before backtracking. Reveals strongly-connected structure.
Computing Medium

0/1 Knapsack: DP Table Fill

A 2D table fills in row by row. Each cell takes the best of "skip" or "include the current item".
Computing Medium

Longest Common Subsequence

A DP grid finds the longest shared sequence between two strings. Foundation of diff and version control.
Computing Medium

Levenshtein Edit Distance

Min insertions/deletions/substitutions to turn one string into another. The DP grid that powers spellcheck.
Computing Simple

Fibonacci: Memo vs Recompute

Naive recursion explodes into O(2^n). Memoization collapses it to O(n) by caching subproblems.
Computing Medium

Greedy vs DP: When Greedy Fails

Coin change with US coins works greedily. With {1,3,4} and target 6 it produces a wrong answer.
Computing Medium

Topological Sort

Kahn's algorithm peels off zero in-degree nodes. The build/dependency-order foundation.
Computing Medium

Union-Find with Path Compression

Two trees merge under a single root. Path compression flattens future lookups to near-constant.
Computing Medium

Kruskal's Minimum Spanning Tree

Sort edges by weight, greedily accept any that does not form a cycle. Union-find detects cycles.
Computing Medium

Prim's Minimum Spanning Tree

Grow a single tree from a seed by always taking the cheapest crossing edge.
Computing Simple

Two-Pointer Sweep

Convergent pointers solve sorted-array problems in linear time. The interview classic.
Computing Simple

Sliding Window

A window of fixed or variable size sweeps the array. Adds the new element, drops the old.
Computing Simple

Big-O Growth Comparison

O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n) plotted side by side. The shape of scale.

Networking 18 live

TCP, TLS, DNS, BGP, HTTP/2, QUIC, NAT, CDN.

Computing Rich

TCP State Machine

CLOSED to ESTABLISHED to TIME_WAIT and back. The full TCP lifecycle as a state diagram.
Computing Rich

TLS 1.3 Handshake

Client hello, key share, server response, finished. Encrypted in 1-RTT, optional 0-RTT resumption.
Computing Rich

DNS Resolution Path

Stub resolver to recursive to root to TLD to authoritative. The query that finds your server.
Computing Rich

HTTP/2 Frames and Streams

Multiple streams interleave on a single TCP connection. Head-of-line blocking gone (mostly).
Computing Rich

QUIC: 1-RTT Encrypted Setup

TLS 1.3 fused into the transport. 0-RTT resumption, per-stream loss recovery.
Computing Rich

BGP Route Propagation

Autonomous systems advertise prefixes; neighbors apply policy and re-advertise. The internet routes itself.
Computing Medium

NAT Traversal: Hole Punching

Two peers behind NATs synchronize via a rendezvous server, then connect directly.
Computing Medium

CDN Edge Routing

Anycast IPs route a user to the nearest PoP. Cache hit serves from edge; miss goes to origin.
Computing Medium

Anycast: Same IP, Many Locations

BGP advertises one prefix from many sites. Routers pick the closest by AS-path.
Computing Medium

Load Balancer Algorithms

Round-robin, least-connections, weighted, hash-based. Same traffic, different distributions.
Computing Rich

TCP Congestion Control

Slow start, congestion avoidance, fast retransmit, fast recovery. The cwnd dance.
Computing Simple

OSI vs TCP/IP Layer Stack

Seven layers vs four. What encapsulation looks like as a packet flows down and up.
Computing Simple

CIDR & Subnetting

Prefix length determines network and host bits. /24 gives 254 usable, /16 gives 65k.
Computing Simple

TCP vs UDP

Reliable, ordered, slow setup vs unreliable, unordered, instant. Two transport philosophies.
Computing Simple

HTTP Status Code Decision Tree

1xx info, 2xx success, 3xx redirect, 4xx client error, 5xx server error. Pick the right code.
Computing Medium

MTU & Fragmentation

Packets larger than the path MTU fragment. Path-MTU discovery avoids the cost.
Computing Medium

Reading a Packet Capture

A real HTTP fetch annotated frame by frame. SYN, handshake, GET, response, FIN.
Computing Medium

Reverse Proxy: Single Front, Many Backends

TLS termination, routing, caching, load-balancing all at the edge layer.

Systems 16 live

Cache hierarchy, GC, scheduling, virtual memory, syscalls.

Computing Rich

CPU Cache Hierarchy: L1 to RAM

L1 hits in 1ns, L2 in 4ns, L3 in 12ns, RAM in 100ns. Each miss is a 10x cliff.
Computing Rich

Virtual Memory: Translation & Paging

Virtual addresses translate via page tables to physical frames. The TLB keeps it fast.
Computing Rich

Garbage Collection: Mark-and-Sweep

Trace from roots, mark reachable, sweep the rest. The classic tracing GC.
Computing Rich

Generational Garbage Collection

Most objects die young. Collect the nursery often, the old gen rarely.
Computing Medium

Copying GC (Cheney)

Two semispaces. Live objects copy from from-space to to-space; the rest is reclaimed by reset.
Computing Medium

CPU Scheduling Algorithms

FIFO, SJF, round-robin, MLFQ, CFS. Each picks the next runnable thread differently.
Computing Medium

System Call Flow

User code traps into the kernel, switches stacks, executes, returns. The user/kernel boundary.
Computing Medium

fork() and exec()

fork duplicates the process; exec replaces its image. Together they birth every Unix program.
Computing Medium

Context Switch Cost

Save registers, swap stacks, flush TLB. Microseconds you pay every time.
Computing Simple

Concurrency vs Parallelism

Concurrency: many tasks make progress. Parallelism: many tasks run simultaneously.
Computing Medium

Mutex vs Read-Write Lock

Mutex: one at a time. RWLock: many readers OR one writer. Pick by workload.
Computing Medium

Producer-Consumer & Bounded Buffer

Producers fill, consumers drain, the buffer enforces backpressure. Two-condition synchronization.
Computing Medium

epoll vs select/poll

O(n) per call vs O(1) with kernel-side state. The leap that enables 100k connections.
Computing Medium

Cache-Friendly Access Patterns

Row-major sweep is fast. Column-major sweep on the same matrix is 10x slower.
Computing Simple

Stack vs Heap Allocation

Stack: bump pointer, free on return. Heap: free-list, manual or GC. Speed vs lifetime.
Computing Medium

Copy-on-Write Pages

Shared pages stay read-only until someone writes. Then a private copy is made.

Databases 16 live

B-trees, LSM trees, indexes, transactions, replication, sharding.

Computing Rich

B-Tree vs LSM Tree

B-trees: in-place updates, fast reads. LSM: append-only writes, compaction in background.
Computing Rich

LSM Tree: Memtable, SSTables, Compaction

Writes go to memory, flush to immutable files, compact in background. Append-only beats random writes.
Computing Rich

Transaction Isolation Levels

Read uncommitted, committed, repeatable read, serializable. Each blocks more anomalies, costs more concurrency.
Computing Rich

Replication Topologies

Single-leader, multi-leader, leaderless. Each has its own consistency and conflict story.
Computing Rich

MVCC: Multi-Version Concurrency Control

Each row has multiple versions tagged by transaction ID. Readers never block writers.
Computing Medium

Sharding Strategies

Range, hash, geo, directory. Each distributes load and survives growth differently.
Computing Medium

Index Types: B-Tree, Hash, GIN, GiST

Different data shapes need different indexes. Equality, range, full-text, geo each have a winner.
Computing Medium

Covering Index & Index-Only Scan

When the index includes all needed columns, the heap is never touched.
Computing Rich

Two-Phase Commit

Coordinator asks every participant to prepare, then to commit. Blocks on coordinator failure.
Computing Medium

CAP Theorem in Practice

During a partition, you choose C or A. The everyday choice between consistency and availability.
Computing Medium

SQL vs NoSQL: Picking a Store

Relational, document, KV, graph, wide-column, time-series. Each shines on a workload shape.
Computing Medium

Write-Ahead Log (WAL)

Log changes before mutating pages. Crash recovery just replays the log.
Computing Medium

OLTP vs OLAP

Row stores serve point queries; column stores scan billions of rows for aggregates.
Computing Medium

Query Planner: From SQL to Plan

Parse, rewrite, cost-based plan selection, execute. Why the same SQL runs in 1ms or 1 second.
Computing Medium

Hash, Merge, and Nested Loop Joins

Three join algorithms, three workload sweet spots. The optimizer picks per query.
Computing Simple

Connection Pooling

Share a small pool of DB connections across many app threads. Avoid the per-connect cost.

Data structures 15 live

Trees, heaps, hash tables, tries, graphs, bloom filters.

Computing Rich

BST Rotations: Left and Right

A single node rotation rebalances a tree without losing the in-order property.
Computing Rich

AVL Tree: Auto-Balancing

After every insert, the tree checks balance factors and rotates back to height-balanced. O(log n) guaranteed.
Computing Rich

Hash Table Collision Resolution

Chaining vs open addressing (linear, quadratic, double hashing). Same load, very different behavior.
Computing Rich

Red-Black Tree Invariants

Five color rules keep the tree balanced within a 2x factor. The map/set workhorse.
Computing Medium

Binary Heap: Insert & Extract

Sift up on insert, sift down on extract. The implicit array layout that powers priority queues.
Computing Medium

Trie: Prefix Tree

Each node holds a character; common prefixes share paths. Autocomplete and routing-table lookups.
Computing Medium

Bloom Filter: Probabilistic Membership

k hash functions set k bits. False positives possible; false negatives impossible.
Computing Simple

Graph: Adjacency List vs Matrix

List wins on sparse graphs, matrix wins on dense. Memory and query trade-offs side by side.
Computing Simple

Doubly Linked List Operations

O(1) insert and delete given a node pointer. The basis for LRU caches and deques.
Computing Medium

LRU Cache: Hashmap + Doubly Linked List

A hashmap for O(1) lookup, a list for O(1) recency tracking. The eviction classic.
Computing Medium

Segment Tree: Range Queries

O(log n) range sums or mins on a mutable array. Each internal node owns an interval.
Computing Medium

Fenwick (BIT): Implicit Range Sums

A single array encodes prefix sums via low-bit indexing. Range sums and updates in O(log n).
Computing Simple

Queue vs Stack

FIFO vs LIFO, both O(1) push/pop. The fundamental order primitives.
Computing Medium

Cuckoo Hashing

Each key has two homes. On collision the resident is evicted to its alternate slot, recursively.
Computing Medium

Disjoint Set Forest

Trees representing sets, with union-by-rank and path compression. Near-constant amortized operations.

Security 14 live

OAuth, JWT, hashing, signatures, TLS handshake, threat models.

Computing Rich

OAuth 2.0 Authorization Code + PKCE

User to authz server, code back to app, code exchanged for token. PKCE blocks the interception attack.
Computing Medium

JWT: Header, Payload, Signature

Three base64 chunks separated by dots. Stateless auth verified by signature.
Computing Rich

TLS Handshake: Security Angle

How TLS 1.3 prevents downgrade, MITM, and replay. The crypto primitives in motion.
Computing Medium

Cryptographic Hash Properties

Pre-image resistance, second pre-image, collision resistance. Fingerprints that should never collide.
Computing Medium

HMAC vs RSA Signatures

Symmetric secret vs asymmetric keypair. Same goal, different trust model.
Computing Medium

X.509 Certificate Chain

Leaf cert, intermediates, root. Each signed by the next, anchored by a trusted root.
Computing Medium

OIDC ID Token vs Access Token

ID token says who the user is. Access token says what the app can do. Different audiences, different lifetimes.
Computing Medium

Session Cookies vs Bearer Tokens

Server-side state with httpOnly cookies vs stateless JWTs in headers. Each has its sharp edges.
Computing Medium

CSRF: Cross-Site Request Forgery

Attacker tricks browser into sending a state-changing request with the victim's cookies.
Computing Medium

XSS: Cross-Site Scripting

Attacker-injected script runs in your origin. Steals tokens, defaces, pivots.
Computing Medium

SQL Injection

Untrusted input concatenated into SQL becomes code. Parameterization is the cure.
Computing Medium

MFA & TOTP

Password is something you know. TOTP is something you have. Together: two factors.
Computing Medium

STRIDE Threat Model

Spoofing, Tampering, Repudiation, Info disclosure, DoS, Elevation. Six lenses on every component.
Computing Simple

Kerckhoffs's Principle

A cryptosystem must be secure even if everything except the key is public knowledge.
FAQ

Common questions about Computing diagrams

Where can I get free animated computing diagrams for my website?

Scrollchart is a free library of animated, embeddable diagrams. The Computing section covers the most common concepts and frameworks in the field. Each diagram embeds with one line of HTML, no account required, no watermark.

How do I embed a free animated computing diagram in WordPress?

Copy the embed snippet from the diagram page on Scrollchart and paste it into a custom HTML block in your WordPress editor. The diagram loads automatically and scroll-paints into view. No plugin or API key needed.

Is there a free library of animated computing diagrams I can embed without coding?

Scrollchart provides ready-to-embed animated diagrams across computing and 35 other categories. The embed is a single line of HTML that works in any CMS, including WordPress, Webflow, Ghost, Substack, and plain HTML pages.

Do Scrollchart computing diagrams include explanatory text?

Yes. Each diagram ships with a tabbed explainer panel covering what the diagram shows, the research behind it, and how to interpret it. The text is served from scrollchart.com and rendered directly in your page's DOM so it is indexed by search engines.

Don't see what you need?

Generate a custom computing diagram from a prompt, or request a new template. Most ship within two weeks.

Try the AI generator Request a diagram