# Intraview

> AI creates code tours. You refine them visually. Your team onboards faster. Intraview is a free VS Code extension that lets AI agents build interactive walkthroughs of any codebase, stored as git-versioned files in your workspace.

The Explore section publishes guided tours of popular open-source projects.

## Marketing

- [Home](https://www.intraview.ai/): What Intraview is, how it works, install link
- [Getting Started](https://www.intraview.ai/getting-started/): Step-by-step setup with any AI agent
- [Pricing](https://www.intraview.ai/pricing/): Free vs paid tiers

## Explore

- [Code Tour Registry](https://www.intraview.ai/explore/): Browse all open-source code tours
- [Redis hub](https://www.intraview.ai/explore/redis/redis/): In-memory data structure store used as a database, cache, message broker, and streaming engine.
- [Pretext hub](https://www.intraview.ai/explore/chenglou/pretext/): TypeScript library for multiline text measurement and layout without DOM reflow.
- [Hermes Agent hub](https://www.intraview.ai/explore/NousResearch/hermes-agent/): Self-improving open-source AI agent with a closed learning loop, persistent memory, and a multi-platform messaging gateway.
- [sift-kg hub](https://www.intraview.ai/explore/juanceresa/sift-kg/): Python CLI that turns document collections into structured knowledge graphs via LLM extraction with a human-in-the-loop deduplication step.
- [The Algorithms - Python hub](https://www.intraview.ai/explore/TheAlgorithms/Python/): Educational reference implementations of every classical algorithm in Python. Type-hinted, doctested, MIT-licensed. About 1,381 algorithms across 43 categories.
- [Warp hub](https://www.intraview.ai/explore/warpdotdev/warp/): Rust-based agentic development environment, born out of the terminal. Open-sourced April 2026 with OpenAI as founding sponsor.
- [Lightpanda hub](https://www.intraview.ai/explore/lightpanda-io/browser/): Headless browser written from scratch in Zig. No compositor, no layout, no GPU. 16x less memory and 9x faster than headless Chrome on a 100-page benchmark.

## Tours

- [Redis -- Getting Started with Your First Contribution to Redis](https://www.intraview.ai/explore/redis/redis/tours/first-contribution/): Walk through README orientation, the root Makefile, the redis-server main() entry, the runtest Tcl harness, the src/commands/ command-definition pattern, CONTRIBUTING.md and the tri-license, and a pointer to the event loop. (7 stops, ~18 min, beginner)
- [Redis -- Architecture Grand Tour](https://www.intraview.ai/explore/redis/redis/tours/architecture/): Walk through the Redis event loop, command dispatch, data structures, and persistence layer. (8 stops, ~25 min, intermediate)
- [Redis -- Redis Replication: How Primaries and Replicas Stay in Sync](https://www.intraview.ai/explore/redis/redis/tours/replication/): How a replica connects, bootstraps from an RDB snapshot, and stays current through command propagation (7 stops, ~25 min, intermediate)
- [Redis -- Redis Streams: A Log With Consumer Groups](https://www.intraview.ai/explore/redis/redis/tours/streams/): How Redis stores an append-only log in a radix tree, delivers messages to consumer groups, and tracks unacknowledged entries in the pending entries list (7 stops, ~30 min, intermediate)
- [Redis -- Redis Sentinel: Watch, Vote, Fail Over](https://www.intraview.ai/explore/redis/redis/tours/sentinel/): How Sentinel detects failures, elects a leader, and promotes a replica without human intervention (7 stops, ~30 min, intermediate)
- [Redis -- Redis Pub/Sub: Channels, Patterns, and Keyspace Notifications](https://www.intraview.ai/explore/redis/redis/tours/pubsub/): How Redis routes messages from publishers to subscribers using channel dicts, glob patterns, and automatic keyspace events (6 stops, ~20 min, intermediate)
- [Redis -- Redis Persistence Deep Dive: RDB, AOF, and the Hybrid](https://www.intraview.ai/explore/redis/redis/tours/persistence/): How Redis survives a restart: binary snapshots, append-only logs, and the hybrid mode that combines both (8 stops, ~30 min, intermediate)
- [Redis -- Redis Cluster: Sharding, Gossip, and Failover](https://www.intraview.ai/explore/redis/redis/tours/cluster/): How Redis distributes data across nodes, detects failures through gossip, and promotes replicas without human intervention (7 stops, ~30 min, advanced)
- [Redis -- Redis Data Structures & Encoding: How Values Live in Memory](https://www.intraview.ai/explore/redis/redis/tours/data-structures/): From raw bytes to skip lists: the memory layouts that make Redis fast and compact (8 stops, ~30 min, advanced)
- [Redis -- RESP Protocol Deep Dive: How Redis Talks Over the Wire](https://www.intraview.ai/explore/redis/redis/tours/resp-protocol/): Eight stops through the parsing, reply, and negotiation code that drives every Redis client connection (8 stops, ~30 min, advanced)
- [Pretext -- Getting Started with Your First Contribution to Pretext](https://www.intraview.ai/explore/chenglou/pretext/tours/first-contribution/): Walk through install, the package.json scripts, the main API, and the testing convention used in this small TypeScript library. (5 stops, ~15 min, beginner)
- [Pretext -- Architecture Grand Tour](https://www.intraview.ai/explore/chenglou/pretext/tours/architecture/): Trace the two-phase design: expensive measurement via Canvas, then pure-arithmetic layout at 0.0002ms per block. (7 stops, ~20 min, intermediate)
- [Hermes Agent -- Getting Started with Your First Contribution to Hermes Agent](https://www.intraview.ai/explore/NousResearch/hermes-agent/tours/first-contribution/): Where to put new code in a 70-file Python agent with a learning loop, a messaging gateway, and a self-registering tool system (7 stops, ~30 min, beginner)
- [Hermes Agent -- The Self-Improving Skill System: How Hermes Builds and Refines Its Own Procedures](https://www.intraview.ai/explore/NousResearch/hermes-agent/tours/skills-system/): How Hermes discovers, loads, preprocesses, invokes, and tracks its own skills across the full lifecycle (7 stops, ~20 min, intermediate)
- [Hermes Agent -- The Multi-Platform Gateway: One Agent, Six Chat Platforms, Shared Sessions](https://www.intraview.ai/explore/NousResearch/hermes-agent/tours/gateway/): How a Telegram message and a Discord DM share the same agent state inside Hermes (7 stops, ~30 min, intermediate)
- [Hermes Agent -- Context Compression: Keeping Long Conversations Inside Token Budgets](https://www.intraview.ai/explore/NousResearch/hermes-agent/tours/context-compression/): How Hermes detects context pressure, summarizes the middle of a conversation, and hands off to itself without losing the thread (7 stops, ~30 min, intermediate)
- [Hermes Agent -- Provider-Agnostic LLM Adapters: One Agent, Eight APIs](https://www.intraview.ai/explore/NousResearch/hermes-agent/tours/llm-adapters/): How Hermes Agent normalizes OpenAI, Anthropic, Bedrock, Gemini, Codex Responses, and custom endpoints behind a single call interface (6 stops, ~30 min, intermediate)
- [Hermes Agent -- Hermes Memory Architecture: How an Agent Remembers You Across Sessions](https://www.intraview.ai/explore/NousResearch/hermes-agent/tours/memory-architecture/): How a fact travels from a conversation into long-term storage and back into a future prompt (7 stops, ~30 min, advanced)
- [sift-kg -- Getting Started with Your First Contribution to sift-kg](https://www.intraview.ai/explore/juanceresa/sift-kg/tours/first-contribution/): Walk through install, dev setup, the sift CLI, the testing convention, the YAML domain extension point, and where to read next. (6 stops, ~16 min, beginner)
- [sift-kg -- From Documents to Knowledge Graph: The Sifter Pipeline](https://www.intraview.ai/explore/juanceresa/sift-kg/tours/pipeline/): Walk the full execution path: CLI dispatch, LLM extraction, graph construction, resolution, and the merge step that mutates the graph. (7 stops, ~25 min, intermediate)
- [sift-kg -- Human-in-the-Loop Entity Resolution](https://www.intraview.ai/explore/juanceresa/sift-kg/tours/entity-resolution/): How sift-kg layers deterministic dedup, LLM proposals, YAML review, and graph mutation so nothing gets merged without your approval. (6 stops, ~22 min, intermediate)
- [The Algorithms - Python -- Getting Started with Your First Contribution to TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/first-contribution/): Walk the README disclaimer, the CONTRIBUTING.md algorithm requirements, the canonical insertion_sort file shape, the auto-generated DIRECTORY.md, the pytest --doctest-modules gate, and the path to deeper algorithm tours. (6 stops, ~16 min, beginner)
- [The Algorithms - Python -- Navigating TheAlgorithms/Python: A Tour of the 43 Categories](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/navigation/): Sample one canonical algorithm from each major category (a sort, a search, a graph traversal, a DP class, a cipher) and end on the autoapi_dirs list that names every category. (7 stops, ~18 min, beginner)
- [The Algorithms - Python -- How Bubble Sort Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/bubble-sort/): Compare adjacent elements, swap if out of order, repeat. The algorithm that appears in every first-year course because the swapping motion is easy to picture. (6 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How Insertion Sort Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/insertion-sort/): Pick the next element, shift everything larger one position right, drop the element into the gap. The algorithm that outperforms quicksort on small runs. (6 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How Selection Sort Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/selection-sort/): Find the minimum of the unsorted region, swap it to the front, repeat. O(n squared) always, but only O(n) swaps total. (5 stops, ~10 min, intermediate)
- [The Algorithms - Python -- How Mergesort Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/mergesort/): Split the list in half, sort each half recursively, merge the two sorted halves. The first algorithm written for a stored-program computer. (6 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How Quicksort Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/quicksort/): A random pivot, a partition into lesser and greater, two recursive calls. The 1959 algorithm that still drives most stdlib sorts. (6 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How Heapsort Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/heapsort/): Build a max-heap over the array, then repeatedly swap the root to the back and restore the heap. O(n log n) worst case with no extra memory. (6 stops, ~16 min, intermediate)
- [The Algorithms - Python -- How Radix Sort Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/radix-sort/): Sort by least significant digit, then next digit, repeat. Non-comparison sort that runs in O(d times n) rather than O(n log n). (5 stops, ~12 min, intermediate)
- [The Algorithms - Python -- How Counting Sort Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/counting-sort/): No comparisons, no pivots. Count key frequencies, prefix-sum them, then place each element at its exact output index in one backward pass. (6 stops, ~15 min, intermediate)
- [The Algorithms - Python -- How Linear Search Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/linear-search/): Scan every element in order, return the index on match, return -1 on miss. The lower bound for searching unsorted data. (5 stops, ~12 min, intermediate)
- [The Algorithms - Python -- How Binary Search Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/binary-search/): Halve the search space on every step. The 1946 algorithm that still trips up professionals on overflow and off-by-one errors. (6 stops, ~16 min, intermediate)
- [The Algorithms - Python -- How Jump Search Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/jump-search/): Jump through sorted data in square-root-sized blocks, then linear-search the candidate block. O(sqrt(n)) with no recursion, no pivots. (5 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How BFS Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/breadth-first-search/): Visit every neighbor before going deeper. The FIFO queue invariant that guarantees shortest-path distances on unweighted graphs. (6 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How DFS Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/depth-first-search/): Follow a path as deep as it goes before backtracking. The iterative stack-based implementation that mirrors the recursive structure without blowing the call stack. (5 stops, ~12 min, intermediate)
- [The Algorithms - Python -- How Dijkstra's Algorithm Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/dijkstra/): A min-heap of (cost, node) tuples, a visited set, and a single relaxation loop. The 1956 algorithm at the core of OSPF and IS-IS routing. (7 stops, ~18 min, intermediate)
- [The Algorithms - Python -- How A* Search Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/a-star/): Combine actual path cost with a heuristic estimate of remaining distance. The 1968 algorithm built for a robot, now in every map and game engine. (6 stops, ~18 min, intermediate)
- [The Algorithms - Python -- How Bellman-Ford Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/bellman-ford/): Relax every edge V-1 times, then run one more pass to detect negative cycles. The algorithm Dijkstra cannot replace. (6 stops, ~16 min, intermediate)
- [The Algorithms - Python -- How Kruskal's Algorithm Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/kruskal-mst/): Sort edges by weight, then add each one unless it creates a cycle. Union-find with path compression in 46 lines. (5 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How Fibonacci DP Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/fibonacci-dp/): Cache the sequence on a class instance, extend it on demand, return a slice. The canonical example of memoization replacing exponential recursion. (5 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How the 0/1 Knapsack DP Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/knapsack-01/): Fill a capacity-by-item table bottom-up, then trace back through it to recover which items go in the bag. (6 stops, ~20 min, intermediate)
- [The Algorithms - Python -- How Longest Common Subsequence Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/longest-common-subsequence/): A 2-D DP table, one recurrence, and a traceback walk. The algorithm at the core of diff, git-merge, and DNA sequence alignment. (6 stops, ~18 min, intermediate)
- [The Algorithms - Python -- How Edit Distance Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/edit-distance/): Count the minimum insertions, deletions, and substitutions to transform one string into another. The 1965 algorithm behind spell-check, fuzzy search, and DNA alignment. (6 stops, ~18 min, intermediate)
- [The Algorithms - Python -- How the Sieve of Eratosthenes Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/sieve-of-eratosthenes/): Mark every multiple of each found prime starting at its square. What remains is a list of primes, produced in O(n log log n). (5 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How the Caesar Cipher Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/caesar-cipher/): A modular shift over an alphabet, mirrored to decrypt, exhausted to brute-force. The oldest attested cipher in the Western record. (6 stops, ~16 min, intermediate)
- [The Algorithms - Python -- How RSA Encryption Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/rsa-cipher/): Split the message into fixed-size integer blocks, raise each block to a modular power, and undo it with the private exponent. (6 stops, ~20 min, intermediate)
- [The Algorithms - Python -- How SHA-1 Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/sha-1/): Pad the message, split into 512-bit blocks, expand each block to 80 words, run 80 rounds of bit operations, accumulate five 32-bit words into a 160-bit digest. (6 stops, ~20 min, intermediate)
- [The Algorithms - Python -- How MD5 Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/md5/): Four 32-bit state words, 64 rounds, a sin-derived constant table. The 1991 algorithm that still shows up in checksums everywhere. (6 stops, ~20 min, intermediate)
- [The Algorithms - Python -- How the Knuth-Morris-Pratt Algorithm Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/kmp-string-match/): Preprocess the pattern into a failure array, then scan the text without backtracking. The 1977 algorithm that makes grep and DNA search O(n+m). (6 stops, ~16 min, intermediate)
- [The Algorithms - Python -- How Rabin-Karp String Matching Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/rabin-karp/): Hash the pattern, slide a rolling hash across the text, confirm on match. The 1987 algorithm that makes multi-pattern search practical. (5 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How a Bloom Filter Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/bloom-filter/): A bitarray, two hash functions, and a membership check that never gives false-negatives. Burton Bloom's 1970 data structure still in production databases. (6 stops, ~14 min, intermediate)
- [The Algorithms - Python -- How an LRU Cache Works](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/lru-cache/): A doubly-linked list plus a hashmap gives O(1) get and put. The eviction policy at the core of CPU caches, browser caches, and functools.lru_cache. (6 stops, ~18 min, intermediate)
- [The Algorithms - Python -- Sorting Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-sorts/): Seven sorting strategies side by side: from the classroom bubble loop to radix buckets. (7 stops, ~14 min, beginner)
- [The Algorithms - Python -- Search Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-searches/): Seven search strategies from a simple scan to partition-based selection, each with a different trade-off. (7 stops, ~14 min, beginner)
- [The Algorithms - Python -- Cipher Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-ciphers/): Seven ciphers from ancient Rome to Diffie-Hellman: each a different answer to the question of what makes a message unreadable. (7 stops, ~16 min, intermediate)
- [The Algorithms - Python -- Hash Functions in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-hashes/): Six hash algorithms from a 13-byte checksum to 256-bit cryptographic digests: each trading reliability for speed differently. (6 stops, ~12 min, beginner)
- [The Algorithms - Python -- Data Structures in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-data-structures/): Seven fundamental data structures side by side: the pointer chain, the key-ordered tree, the self-balancing tree, the heap, the hash table, the union-find, and the prefix tree. (7 stops, ~16 min, beginner)
- [The Algorithms - Python -- Conversion Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-conversions/): Seven base, numeral, and unit conversions showing how repeated division, recursion, lookup tables, and pivot factors each solve the same family of problems. (7 stops, ~14 min, beginner)
- [The Algorithms - Python -- Bit Manipulation in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-bit-manipulation/): Seven techniques that use bitwise operations to count, test, flip, reverse, and encode integers without arithmetic. (7 stops, ~14 min, beginner)
- [The Algorithms - Python -- String Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-strings/): Seven string search and comparison algorithms from KMP failure arrays to Aho-Corasick automata. (7 stops, ~14 min, intermediate)
- [The Algorithms - Python -- Maths Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-maths/): Seven mathematical algorithms from prime sieves to the Chinese Remainder Theorem. (7 stops, ~14 min, intermediate)
- [The Algorithms - Python -- Geometry Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-geometry/): Four stops from primitive shapes to convex hull algorithms, with cross-product orientation as the shared computational primitive. (4 stops, ~10 min, intermediate)
- [The Algorithms - Python -- Matrix Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-matrix/): Six matrix operations from elementwise addition to Pascal's triangle generation. (6 stops, ~12 min, intermediate)
- [The Algorithms - Python -- Graph Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-graphs/): Seven graph traversal and shortest-path strategies from BFS queues to Prim's greedy expansion. (7 stops, ~14 min, intermediate)
- [The Algorithms - Python -- Backtracking Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-backtracking/): Seven constraint-satisfaction problems solved by the same pattern: try a placement, recurse, and undo it when the branch fails. (7 stops, ~14 min, intermediate)
- [The Algorithms - Python -- Greedy Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-greedy-methods/): Five problems where the locally optimal choice at each step produces the globally optimal result. (5 stops, ~11 min, intermediate)
- [The Algorithms - Python -- Divide and Conquer Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-divide-and-conquer/): Six algorithms that split a problem in half, solve each half independently, and combine the results: from sorting to matrix multiplication to geometry. (6 stops, ~12 min, intermediate)
- [The Algorithms - Python -- Dynamic Programming in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-dp/): Seven DP patterns from memoized sequences to all-pairs shortest paths. (7 stops, ~14 min, intermediate)
- [The Algorithms - Python -- Linear Algebra Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-linear-algebra/): Seven direct solvers and iterative methods, from Gaussian elimination to conjugate gradient, each exposing a different trade-off in numerical linear algebra. (7 stops, ~14 min, intermediate)
- [The Algorithms - Python -- Machine Learning Algorithms in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-machine-learning/): Seven classical ML algorithms from linear models to kernel machines, each implemented from scratch in plain NumPy. (7 stops, ~14 min, intermediate)
- [The Algorithms - Python -- Neural Networks in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-neural-network/): Five files tracing how a network learns: from a single-neuron forward pass to backpropagation, multi-layer weight matrices, and the activation functions that make it possible. (5 stops, ~12 min, intermediate)
- [The Algorithms - Python -- Project Euler Solutions in TheAlgorithms/Python](https://www.intraview.ai/explore/TheAlgorithms/Python/tours/category-project-euler/): The first seven Project Euler problems, each solved in a single Python function with doctests, showing how mathematical insight reduces brute force to a handful of lines. (7 stops, ~14 min, intermediate)
- [Warp -- Getting Started with Your First Contribution to Warp](https://www.intraview.ai/explore/warpdotdev/warp/tours/first-contribution/): Walk through README orientation, script/bootstrap, script/run, the presubmit gate, a contributor-facing SKILL.md, the CONTRIBUTING.md flow, and pointers to the deeper architecture tours. (7 stops, ~18 min, beginner)
- [Warp -- .agents/skills: Building a Repo for AI Contributors](https://www.intraview.ai/explore/warpdotdev/warp/tours/agents-skills/): How Warp ships SKILL.md files, structured specs, and a contribution flow that lets agents land production code. (6 stops, ~18 min, beginner)
- [Warp -- Inside the Rust Terminal](https://www.intraview.ai/explore/warpdotdev/warp/tours/architecture/): Walk the workspace, the Tokio runtime, the wgpu glyph shader, font-kit rasterization, shell integration, the typed IPC, and the build scripts. (7 stops, ~25 min, intermediate)
- [Lightpanda -- Getting Started with Your First Contribution to Lightpanda](https://www.intraview.ai/explore/lightpanda-io/browser/tours/first-contribution/): Walk through the README quick start, the Makefile build targets, the CLI run command, the test harness, the src/browser/webapi/ extension point, and CONTRIBUTING.md. (7 stops, ~15 min, beginner)
- [Lightpanda -- Post-Chrome Browser Architecture](https://www.intraview.ai/explore/lightpanda-io/browser/tours/architecture/): Walk the Zig build graph, the module map, the libcurl HTTP layer, the html5ever Rust-to-Zig parser bridge, the v8 embedding, and the headless event loop. (7 stops, ~22 min, intermediate)
- [Lightpanda -- Zig Memory Management for a Browser](https://www.intraview.ai/explore/lightpanda-io/browser/tours/memory/): From the GPA-vs-c_allocator split in main, through the per-page arena pool, to the libcurl allocator boundary and the v8 memory pressure hints. (6 stops, ~18 min, advanced)

## Optional

- [Privacy Policy](https://www.intraview.ai/privacy/)
- [Terms of Service](https://www.intraview.ai/terms/)