> Neural Download

Async Await Is Just a Bookmark

Most developers think async/await runs things in parallel. Wrong. It's just a bookmark — a pausable function that saves its place and steps aside.

Backpropagation: The Algorithm That Taught Machines to Learn

The chain rule meets gradient descent. Watch how neural networks learn by propagating errors backward through every layer.

How Databases Search a Billion Rows

Every database you use is built on B-trees. See how they minimize disk I/O to search billions of rows efficiently.

Cdn

Cmux

How Coding Agents Actually Work

How do tools like Claude Code, Cursor, and Devin actually write code? The ReAct loop, tool calling, and context management — animated.

Compiler Pipeline

The CORS Error, Explained

Every web developer has hit the CORS error. This video explains what it actually is and why curl bypasses it.

How DNS Actually Works

Every step of a DNS query visualized — from your browser's cache to root servers and back, in under 7 minutes.

Docker Isn't a VM. Here's What It Actually Is.

Docker containers are not virtual machines. See how namespaces, cgroups, and union filesystems create isolated Linux processes.

DynamoDB Failed 5 Times. Then It Hit 89M req/sec.

The 5 generations of engineering that turned hot partitions into a solved problem — from consistent hashing to global admission control.

The Embedding Space: Where Words Become Geometry

Words as vectors, sentences as geometry. How embedding spaces capture meaning and power modern AI — from Word2Vec to CLIP.

How JavaScript's Event Loop Actually Works

How JavaScript runs 1000 async tasks on a single thread. The call stack, task queue, microtask queue, and Web APIs — visualized.

Why 0.1 + 0.2 ≠ 0.3 in Every Language

Why computers can't represent 0.1 exactly, and what IEEE 754 does about it. The sign-exponent-mantissa encoding, visualized.

Garbage Collection: The Invisible Janitor Inside Your Code

Mark-and-sweep, reference counting, generational collection — how your runtime silently frees memory you forgot about.

Your Branch Is 41 Bytes (Git Internals Explained)

Git is a content-addressable object store, not a diff tracker. See how blobs, trees, and commits actually work under the hood.

What Actually Happens Inside a Hash Map

A deep dive into hash maps — from the core hash-to-index trick, through collisions and resizing, to how Python, Java, and Go implement them differently.

Https

malloc: Secret Memory Dealer in Your Code

Every malloc() call triggers a hidden negotiation between your program and the OS for raw memory. Learn how the heap works, free lists, fragmentation, and memory arenas.

The Secret Compiler Inside Python

Python compiles to bytecode before interpreting it. See the hidden compiler, the dis module, and what actually runs when you hit Enter.

You Don't Hate Recursion. You Were Taught It Wrong.

Recursion visualized from the ground up. Watch the call stack build, see Fibonacci branch into a tree, and understand why memoization changes everything.

Regex: Tiny Pattern, Hidden Machine

Your regex compiles into a state machine every time it runs. NFA construction, DFA conversion, backtracking simulation, and the catastrophic ReDoS attack — all animated.

The Sort Algo Every Language Uses (Not Quicksort)

Every .sort() call in Python, Java, JavaScript, Swift, and Rust runs the same algorithm — and it's not quicksort. It's Timsort. Written by one guy in 2002. Here's why it beat everything CS professors teach you.

Tmux

Why GPT Thinks ChatGPT Is Three Words

BPE, token boundaries, and glitch tokens — why language models see text differently than you do.

How Transformers See Every Word at Once

Self-attention, query-key-value, feed-forward networks, and generation — the full transformer architecture, animated step by step.

Vim Isn't an Editor. It's a Language.

Vim commands aren't random shortcuts — they're a composable language. Learn the verb + noun grammar, text objects, the dot command, and how the multiplication effect gives you hundreds of commands from a handful of building blocks.

Virtual Memory: Your Program Lives in a Lie

Your program's memory addresses are a lie. Page tables, TLBs, and swap space — the OS abstraction that makes multitasking possible.

How Chat Apps Send Messages Instantly (WebSockets Breakdown)

HTTP hangs up after every message. WebSockets keep the line open. The protocol underneath chat apps, multiplayer games, and live dashboards — from the upgrade handshake to the 101 switch to persistent frames.

6 Minutes to Finally Understand SOLID Principles

Five letters every developer has seen in a PR comment, an interview, or a job posting — and most have nodded without really understanding them. SRP isn't one method per class. OCP isn't never modify code. Liskov isn't just about inheritance. Here's what SOLID actually means, in six minutes.

How Git Merge Actually Works

Most developers think git merge just combines two branches. The truth: it finds a secret third file — the merge base — and uses three-way comparison to figure out who changed what.