Distributed Snapshots: The Chandy-Lamport Algorithm, Lai-Yang, and the Foundations of Consistent Global State

In 1985, K. Mani Chandy and Leslie Lamport published a paper with an unassuming title: “Distributed Snapshots: Determining Global States of Distributed Systems.” The paper was six pages long. It introduced one algorithm (with a correctness proof) and one application (stable property detection). And it became one of the most influential papers in distributed systems, inspiring decades of work on checkpointing, rollback recovery, deadlock detection, and distributed debugging.

The problem Chandy and Lamport solved is deceptively simple to state: given a distributed system consisting of processes that communicate by sending messages over channels, how can you capture a consistent snapshot of the global state — the state of every process and the contents of every channel — without stopping the system, without a global clock, and without a coordinator that knows everything?

This post is a deep dive into the Chandy-Lamport algorithm and its intellectual descendants. We will walk through the algorithm itself, the crucial FIFO channel assumption, the Lai-Yang algorithm that relaxes this assumption, and the practical applications in checkpointing, deadlock detection, and distributed debugging.

1. What Is a Consistent Global State?

A global state is the collection of the states of all processes and all channels in the system. A process state is the values of its variables (or, more abstractly, its execution history up to some point). A channel state is the sequence of messages that have been sent but not yet received — the messages “in flight.”

Not every global state is consistent. A consistent global state is one that could have occurred in some execution of the system — roughly, it respects causality. Formally: a global state is consistent if, for every message m that has been received (according to the receiver’s state), m has also been sent (according to the sender’s state). Equivalently: the global state does not contain any “orphan” messages (received but not sent) and does not omit any messages that were sent and should have been received (sent but not received, if the receiver has advanced past the point of receipt).

Here is an illustration of consistency vs. inconsistency:

    Process P:  [state A] ----send(m)----> [state B]
    Process Q:  [state X] ----recv(m)----> [state Y]

    Consistent global state: (P at A, Q at X, channel contains m)
    Inconsistent global state: (P at A, Q at Y, channel empty)
                              Q received m, but P hasn't sent it yet!

An inconsistent global state records effects without their causes. This makes it useless for most applications — deadlock detection on an inconsistent state might report a deadlock that never actually occurred, and checkpointing from an inconsistent state could produce an unrecoverable execution.

2. The Chandy-Lamport Algorithm

The Chandy-Lamport algorithm captures a consistent global state using a simple mechanism: marker messages. A marker is a special control message that flows through the channels, telling processes when to record their state and when to start recording incoming messages.

The algorithm works as follows. Any process can initiate a snapshot:

1. Initiator. The initiating process records its local state. Then, for each outgoing channel, it sends a marker message before sending any other messages on that channel. (This ordering is crucial: the marker must precede any post-snapshot messages on that channel.)

2. Non-initiator on first marker. When a process receives a marker on an incoming channel for the first time, it:

   • Records its local state.
   • Marks the channel on which the marker arrived as empty (all messages received before the marker are part of the pre-snapshot channel state; the marker signals the end of that state).
   • For each outgoing channel, it sends a marker before sending any other messages.

3. Non-initiator on subsequent markers. When a process receives a marker on an incoming channel after it has already recorded its state, it records the state of that channel as the sequence of messages received on that channel between the time the process recorded its state and the time the marker arrived. (These are the messages that were in flight when the process recorded its state.)

The algorithm terminates when every process has recorded its state and every channel’s state has been recorded. The collected states — process snapshots and channel message sequences — form a consistent global state.

Here is the algorithm in ASCII timeline form:

    Process P (initiator):
    |                          |
    [Record P's state]         |
    [Send marker on all chans] |
    |                          |
    |--- marker -------------->|---> Process Q
    |                          |
    [Record msgs from Q]       |
    |                          |

    Process Q (non-initiator):
    |                          |
    |<--- marker --------------|
    [Record Q's state]         |
    [Mark P->Q channel empty]  |
    [Send marker on all chans] |
    |                          |
    |--- marker -------------->|---> Process P
    |                          |
    [Record msgs from R]       |

3. The FIFO Channel Assumption

The Chandy-Lamport algorithm assumes that channels are FIFO — messages are delivered in the order they are sent. This assumption is crucial for correctness. Here is why.

Consider a channel from process P to process Q. P sends a marker and then sends message m1. Because the channel is FIFO, the marker arrives at Q before m1. When Q receives the marker, it records its state and marks the channel P→Q as empty. Then, when m1 arrives, Q treats it as a post-snapshot message (it is not included in the channel state). This is correct: m1 was sent after P recorded its state, so it should not be included in the snapshot of the channel.

If the channel were not FIFO, m1 could arrive before the marker. Q would receive m1, then the marker, and would record the channel state as empty — but m1 was actually in flight at the time of the snapshot. The result is an inconsistent global state (m1 is received but not sent — or more precisely, m1 is not recorded in any channel state, but it was sent after P’s snapshot and received before Q’s snapshot).

So the FIFO assumption is necessary for the Chandy-Lamport algorithm. But many real-world systems do not provide FIFO channels — IP networks reorder packets, message queues may have multiple consumers, and overlay networks may route around failures. This motivates the Lai-Yang algorithm.

4. The Lai-Yang Algorithm: Relaxing FIFO

The Lai-Yang algorithm, published in 1987 by Ten-Hwang Lai and Tao-Heng Yang, extends Chandy-Lamport to non-FIFO channels. The key idea is to piggyback a color on each message: white (sent before the snapshot) or red (sent after the snapshot). Each process also maintains a count of white messages sent and received per channel, which allows it to determine exactly which messages were in flight.

The algorithm:

1. The initiator turns red (records its state) and sends a marker on all outgoing channels. From this point, all messages it sends are colored red.

2. When a process receives a marker for the first time, it turns red (records its state). It records the number of white messages received on each incoming channel so far.

3. After turning red, a process records all incoming messages on each channel. When the number of white messages received equals the number of white messages the sender sent before turning red, the channel state is complete.

The number of white messages sent by process P on channel P→Q is determined by: P records, when it turns red, the total number of messages it has sent on that channel (white sent count). Q records, when it turns red, the number of white messages it has received on that channel (white received count). The messages in flight when both processes have turned red are: (white sent count) - (white received count). These messages are captured by Q recording all subsequent messages until the count matches.

5. Applications of Distributed Snapshots

The Chandy-Lamport algorithm was originally motivated by stable property detection: a stable property is one that, once true, remains true forever (e.g., “the system is deadlocked,” “computation has terminated”). If a stable property is true in any consistent global state, it is true in the final state of the system. By taking periodic snapshots and checking the property, you can eventually detect it if it occurs.

The algorithm has found many other applications:

Checkpointing and rollback recovery. A distributed system can take periodic snapshots (checkpoints) using the Chandy-Lamport algorithm. If a process fails, the system can roll back to the most recent consistent snapshot and resume execution from there. This is called “coordinated checkpointing.” The alternative — independent checkpointing, where each process checkpoints independently — can lead to the “domino effect,” where rolling back one process forces others to roll back, cascading back to the initial state.

Deadlock detection. A deadlock occurs when a set of processes are each waiting for a resource held by another process in the set, forming a cycle in the wait-for graph. The Chandy-Lamport algorithm can be used to capture a consistent snapshot of the wait-for graph. If the snapshot contains a cycle, the system is deadlocked (because deadlock is a stable property — once deadlocked, the processes never recover without external intervention).

Distributed debugging. When debugging a distributed system, you often need to answer queries like “was variable x ever greater than y at the same time that process Q was in state S?” These queries require a consistent global state. The Chandy-Lamport algorithm can be triggered on demand (or on a breakpoint) to capture a snapshot for offline analysis.

Garbage collection. In a distributed system with reference counting, a cycle of references across processes will never be collected because each process thinks the remote reference is still live. Distributed snapshots can detect such cycles by capturing a consistent view of the reference graph.

6. Snapshot Algorithms in Practice

Modern distributed systems rarely use the Chandy-Lamport algorithm in its pure form. Instead, they use variants optimized for specific environments:

Apache Flink uses a variant of the Chandy-Lamport algorithm for checkpointing streaming dataflows. Barriers (markers) are injected into the data stream, and each operator checkpoints its state when it receives barriers from all its input channels. This is called “aligned checkpointing” and it ensures exactly-once semantics for streaming computations.

Kafka Streams uses a simpler approach: each processing task checkpoints its local state independently, and the coordination (determining which offsets have been fully processed) is handled by the Kafka broker’s offset commit protocol. This sacrifices global consistency for simplicity and performance — the tradeoff is that recovery may reprocess some messages (at-least-once semantics).

Distributed databases (like CockroachDB and YugabyteDB) use snapshot-based replication: each transaction sees a consistent snapshot of the database as of its start timestamp. This is not the Chandy-Lamport algorithm (it uses MVCC and clock-based ordering rather than marker messages), but it solves the same fundamental problem: providing a consistent view of distributed state.

7. Formal Correctness and Proof Sketch

The correctness of the Chandy-Lamport algorithm can be proven by induction on the number of processes and channels. The key lemma: the recorded global state is reachable from the initial state by a permutation of the original execution where all pre-snapshot events occur before all post-snapshot events. This permutation respects the happened-before relation (because the marker messages separate pre- and post-snapshot events on each channel), so the recorded state is consistent.

The proof relies on the FIFO assumption: the marker arrives before any post-snapshot message on the same channel. If channels are non-FIFO, this ordering is not guaranteed, and the proof fails. The Lai-Yang algorithm restores correctness by explicitly tracking which messages are pre- and post-snapshot using colors and counts.

8. Connections to Other Distributed Algorithms

The Chandy-Lamport algorithm is one of a family of “global state detection” algorithms that includes:

• Termination detection (Dijkstra-Scholten, Safra): Determine whether a distributed computation has terminated (all processes are idle and no messages are in flight). Termination detection is a special case of stable property detection.

• Wave algorithms (echo algorithm, tree algorithm): Propagate a wave of control messages through a network to collect information from all nodes. The Chandy-Lamport markers form a wave.

• Vector clock-based snapshots: Instead of markers, use vector clocks to identify consistent cuts (sets of process states that respect causality). A cut is consistent if no message crosses the cut backward in time (from a post-cut event to a pre-cut event).

9. Summary

The Chandy-Lamport algorithm is a beautiful piece of distributed systems engineering. It solves a seemingly impossible problem — capturing a consistent snapshot of a running distributed system — with a simple, elegant mechanism: marker messages that separate pre-snapshot from post-snapshot events, and the observation that FIFO channels make this separation trivial to enforce.

The algorithm’s influence extends far beyond its original motivation of stable property detection. It is the foundation of distributed checkpointing, a key component of stream processing engines, and a conceptual ancestor of snapshot isolation in distributed databases. Like Lamport’s logical clocks, it is one of those rare ideas that, once understood, seems inevitable — but only after someone brilliant has shown you how it works.

The lesson of Chandy-Lamport is that distributed systems problems are often solved not by eliminating asynchrony but by harnessing it. Markers do not stop the system; they flow through it, piggybacking on the same channels as the data, and the snapshot emerges from the collective behavior of the processes reacting to those markers. This is a deeply distributed way of thinking — no central coordinator, no global clock, just processes following local rules that together produce a globally meaningful result.

10. Consistent Cuts, Causal Barriers, and the Snapshot Lattice

The theoretical foundations of distributed snapshots deserve a deeper treatment. A consistent cut is a set of process states (one per process) such that no message crosses the cut backward — i.e., if a message is received before the cut in the receiver’s history, it must have been sent before the cut in the sender’s history. The Chandy-Lamport algorithm constructs a consistent cut by having marker messages separate pre-cut events from post-cut events.

The set of all consistent cuts forms a lattice under set inclusion. This lattice structure has a profound consequence: for any distributed computation, there is a unique “first” consistent cut (the initial state) and a unique “last” consistent cut (the final state), and the space of all consistent cuts between them is a distributive lattice. This means that the set of possible global states has a rich algebraic structure that can be exploited for debugging, testing, and verification.

Causal barriers are a practical application of this lattice structure. A causal barrier is a synchronization primitive that ensures that all events causally preceding the barrier are visible before any event after the barrier is executed. Causal barriers are used in distributed shared memory systems and in parallel programming frameworks to enforce ordering between tasks without the overhead of full barrier synchronization.

11. Snapshots in Practice: Apache Flink and Streaming Checkpoints

Apache Flink, a widely-used stream processing engine, uses a variant of the Chandy-Lamport algorithm for checkpointing. Flink’s “aligned checkpointing” works as follows:

1. The JobManager periodically injects checkpoint barriers into the data streams. A barrier is a special record that flows through the stream alongside the data records.

2. Each operator has multiple input channels. When it receives a barrier on one input channel, it stops processing data from that channel and buffers any subsequent data. When it has received barriers from all input channels (the “alignment” phase), it checkpoints its local state. After the checkpoint is complete, it broadcasts the barrier to all its output channels.

3. The checkpoint is considered complete when all operators have checkpoints and all barriers have been received. This is a globally consistent snapshot of the streaming computation.

The alignment phase is the key to consistency: by blocking each input channel until the barrier arrives on that channel, Flink ensures that no data that was sent after the checkpoint initiation can be processed before the checkpoint is taken. This is exactly the Chandy-Lamport guarantee — markers (barriers) separate pre-snapshot and post-snapshot data — adapted to a streaming dataflow with multiple parallel channels.

Unaligned checkpointing is a more recent optimization. Instead of blocking input channels until barriers align, Flink can take an “unaligned checkpoint” where the operator checkpoints its state immediately upon receiving the first barrier, and also checkpoints the in-flight data. This reduces checkpoint latency at the cost of larger checkpoint state.

12. Global State Detection Beyond Chandy-Lamport

The Chandy-Lamport algorithm is the foundation, but it is not the only approach to global state detection. Several important variants exist:

The Spezialetti-Kearns algorithm optimizes snapshot collection by having each process send its local snapshot directly to the initiator, rather than propagating snapshots through the marker tree. This reduces the latency of collecting the global snapshot.

The Venkatesan incremental snapshot algorithm captures incremental changes to the global state rather than full snapshots each time. This is useful for monitoring systems where snapshots are taken frequently and most of the state is unchanged.

Vector clock-based snapshots use vector clocks to identify consistent cuts without markers. A process i records its state at a local event with vector clock V. A cut is consistent if, for every pair of processes i and j, V_j[i] <= V_i[i] (the state of process j does not include any events that happened after the state of process i was recorded). Vector clock-based snapshots are more flexible than marker-based snapshots (they do not require FIFO channels) but require O(n) metadata per message.

13. The Philosophical Significance of Distributed Snapshots

The Chandy-Lamport algorithm is more than a practical tool for checkpointing and deadlock detection. It is a philosophical statement about what it means to observe a distributed system. In a sequential system, observation is trivial: you stop the system and look at its state. In a distributed system, stopping the system is impractical (the world doesn’t stop), and there is no privileged “outside” from which to observe — the observers are inside the system, communicating through the same channels as the data they are trying to observe.

The Chandy-Lamport algorithm resolves this paradox by showing that a consistent observation can be constructed without stopping the system. The markers flow through the same channels as the data, and the snapshot emerges from the collective behavior of the processes reacting to those markers. The snapshot is not a single instantaneous picture but a consistent reconstruction of a state that could have occurred.

This idea — that consistency can be achieved without synchronization — is one of the deepest insights in distributed systems. It reappears in many forms: in eventual consistency (the system converges to a consistent state without synchronous replication), in CRDTs (concurrent updates are merged deterministically without coordination), and in snapshot isolation for databases (each transaction sees a consistent snapshot of the database without locking). The Chandy-Lamport algorithm is the archetype for this pattern: use causal ordering (via markers) to construct consistency from asynchrony.

14. Summary (Extended)

The distributed snapshot problem — capture a consistent global state of a running distributed system — is one of the canonical problems in the field. The Chandy-Lamport algorithm solves it elegantly for FIFO channels with marker messages. The Lai-Yang algorithm extends it to non-FIFO channels with message coloring. And the broader framework of consistent cuts, causal barriers, and vector clock-based snapshots provides the theoretical foundation for checkpointing, debugging, and stable property detection.

For the practitioner, the Chandy-Lamport algorithm is implemented in streaming engines (Apache Flink’s aligned checkpointing), in distributed databases (snapshot isolation via MVCC and clock ordering), and in distributed debuggers. For the theorist, it is a window into the deep connection between causality, consistency, and observation in distributed systems. For both, it is a reminder that the best algorithms often seem obvious in retrospect — but only after someone brilliant has shown you how they work.

15. The Distributed Snapshot as a Building Block for Larger Abstractions

The distributed snapshot is not just a standalone algorithm; it is a building block for higher-level distributed abstractions. Understanding these connections reveals the algorithm’s true significance:

Distributed reset. If the snapshot reveals that the system is in an undesirable state (deadlock, livelock, corrupted state), the system can be reset to a previous consistent snapshot. This is the basis of rollback recovery in distributed systems.

Distributed replay. By recording the sequence of snapshots and the messages exchanged between them, a distributed execution can be replayed deterministically. This is the basis of distributed debugging (replaying a failed execution to find the bug) and distributed provenance (tracking how a piece of data was derived).

Distributed monotonic computation. A computation that processes an infinite stream of data can be organized as a sequence of snapshots, each snapshot representing the state after processing a finite prefix of the stream. This is the basis of streaming systems (Spark Streaming, Flink, Kafka Streams) and the lambda architecture (batch layer for periodic snapshots, speed layer for incremental updates between snapshots).

Distributed simulation. A distributed simulation of a physical system (e.g., a weather model, a particle physics simulation) can use snapshots to synchronize the simulation across nodes: each node advances its local simulation to the next consistent cut, exchanges boundary data with neighbors, and repeats. This is the basis of time-warp and conservative synchronization protocols for parallel discrete-event simulation.

The Chandy-Lamport algorithm, viewed through this lens, is not just a clever trick for capturing global state. It is the foundation for a family of techniques that enable distributed systems to observe themselves, recover from failures, replay their histories, and coordinate their progress — without a central coordinator, without a global clock, and without stopping the computation.

16. The Practical Checklist for Distributed Snapshots

For the practitioner implementing distributed snapshots today:

1. If your channels are FIFO and you need a simple, proven algorithm: Use Chandy-Lamport. Implement marker propagation, local state recording, and channel state recording as described. The algorithm is simple enough to implement in a few hundred lines of code.

2. If your channels are non-FIFO (e.g., IP networks, P2P overlays): Use Lai-Yang with message coloring (white/red) and per-channel message counting. The additional complexity is the color piggybacking and the message counting logic.

3. If you are building a stream processing system: Follow Apache Flink’s model: inject barriers into the stream, align on barriers at each operator, and checkpoint operator state. Consider unaligned checkpointing if alignment latency is a concern.

4. If you are building a distributed database: Use MVCC with snapshot timestamps (from HLCs or TrueTime) rather than explicit Chandy-Lamport snapshots. The snapshot is a logical timestamp, not a physical capture of all process states.

5. If you need frequent snapshots for monitoring: Use incremental snapshots (Venkatesan) or vector clock-based snapshots to reduce overhead.

The distributed snapshot is a fundamental building block. Understanding it — and its variants, limitations, and applications — is essential for any distributed systems engineer.

17. Conclusion: The Snapshot as a Fundamental Abstraction

The distributed snapshot is one of the fundamental abstractions of distributed computing, along with consensus, atomic broadcast, and leader election. It solves a problem that is both practically important (checkpointing, debugging, monitoring) and theoretically deep (what does it mean to observe a distributed system without stopping it?).

The Chandy-Lamport algorithm is a model of elegant distributed algorithm design. It uses a minimal mechanism — marker messages flowing through the same channels as the data — to construct a consistent global state from local observations. It works without a global clock, without a central coordinator, and without stopping the system. It is correct for FIFO channels and can be extended (via Lai-Yang’s message coloring) to non-FIFO channels.

The practical impact of distributed snapshots is vast: stream processing engines (Flink, Kafka Streams), distributed databases (MVCC with snapshot isolation), distributed debuggers and replay systems, and the broader framework of consistent cuts and causal barriers. The theoretical impact is equally profound: the lattice of consistent cuts, the connection to vector clocks and causality, and the deep relationship between observation and consistency in distributed systems.

Chandy and Lamport’s 1985 paper was six pages long. It contained one algorithm and one application. And it changed how we think about distributed systems. That is the mark of a truly great paper: not length, not complexity, but insight — the kind of insight that, once understood, seems obvious, but only because someone brilliant showed you the way.

18. The Snapshot as a Debugging Primitive

One of the most practical applications of distributed snapshots is distributed debugging. In a distributed system with hundreds of microservices, a user request may touch dozens of services before returning a response. When something goes wrong — a timeout, an incorrect result, a missing piece of data — debugging requires understanding the state of all services at the moment the request was processed.

Distributed tracing systems (like Jaeger, Zipkin, and Google’s Dapper) do not use full Chandy-Lamport snapshots, but they are conceptually similar: each service annotates the request with timing information (a span), and the spans are collected and assembled into a trace — a causal history of the request’s execution. The trace is a consistent cut: it records the state of each service at the moment it processed the request, and the causal relationships between services are captured by the parent-child relationships between spans.

The key difference is that distributed tracing is best-effort (spans may be lost if a service crashes before reporting) while Chandy-Lamport snapshots are guaranteed to be consistent (if the algorithm terminates). For debugging, best-effort is usually sufficient — you need enough information to diagnose the problem, not a provably complete global state. But the conceptual connection between tracing and snapshots is deep: both are about observing a distributed execution and reconstructing a causal history.

19. Final Summary

The Chandy-Lamport algorithm is one of the foundational results of distributed systems. It solved a problem — how to capture a consistent global state of a distributed system without stopping it — that is both practically important and theoretically deep. Its mechanism — marker messages flowing through channels — is elegant in its simplicity. Its guarantees — consistency, termination, minimal overhead — are precisely specified and proven. And its influence extends to every area of distributed systems: checkpointing, debugging, stream processing, and distributed database consistency.

The algorithm is a testament to the power of a single, simple idea — in this case, the idea that markers can separate past from future, creating a consistent boundary between what was and what will be. That idea has shaped distributed systems for four decades, and it will continue to shape them for decades to come.

20. Final Reflection: Observation Without Interruption

The Chandy-Lamport algorithm solves a problem that is both profoundly practical and deeply philosophical: how to observe a distributed system without stopping it. The solution — marker messages that separate past from future, local snapshots that collectively form a consistent global state — is elegant in its simplicity and far-reaching in its implications. It teaches us that consistency does not require synchronization; that a global view can be constructed from local observations; that the system can observe itself without disrupting itself.

These lessons extend beyond checkpointing and deadlock detection. They inform how we think about debugging (distributed tracing is a form of snapshot), about testing (chaos engineering is deliberate perturbation of a system to observe its behavior), about monitoring (metrics and logs are continuous, partial snapshots of system state). The Chandy-Lamport algorithm is not just an algorithm; it is a way of thinking about distributed systems: as systems that can observe themselves, reason about their own state, and act on that reasoning — all without a central coordinator, a global clock, or a moment of stillness. That is a powerful idea, and it is one of the foundational insights of distributed computing.

21. Closing Words

The Chandy-Lamport algorithm is one of the most elegant results in distributed systems. It solves a problem — capturing a consistent global state without stopping the system — that seems impossible until you see the solution. And the solution is so simple — marker messages flowing through channels — that it seems obvious in retrospect. This is the hallmark of great research: making the impossible seem inevitable. The Chandy-Lamport algorithm has shaped distributed checkpointing, stream processing, distributed debugging, and the broader theory of consistent cuts and causal barriers. It is a foundational result, and it will remain relevant for as long as we build distributed systems.

22. Afterword: The Snapshot as a Way of Seeing

The distributed snapshot is more than an algorithm. It is a way of seeing distributed systems — as systems that can observe themselves, that can construct consistent views of their own state, that can reason about what was and what will be. This capacity for self-observation is what separates distributed systems from mere collections of communicating processes. It enables checkpointing (saving state for recovery), debugging (reconstructing causal histories), monitoring (taking periodic views of system health), and verification (proving that the system satisfies invariants). The Chandy-Lamport algorithm showed us how to do it. Four decades later, we are still discovering the implications of that simple, elegant, profound idea.

23. Coda: The Observing System

A distributed system that can take snapshots of itself is a system that can observe itself. It can answer questions about its own state — “was I deadlocked at time T?” “what was the state of the queue when this request timed out?” “which nodes were participating in the protocol when the leader failed?” — without relying on external observers. This capacity for self-observation is what makes distributed systems manageable. Without it, debugging is guesswork, recovery is a leap of faith, and verification is impossible. The Chandy-Lamport algorithm gave distributed systems the ability to observe themselves. Four decades later, we are still exploring the implications of that gift — for debugging, for testing, for monitoring, for understanding the systems we build and the behaviors they exhibit. The snapshot is not just an algorithm. It is a way of knowing.

The snapshot story has a quiet profundity. It teaches us that a system can know itself — can observe its own state, can reconstruct its own history, can answer questions about what was and what is — without a central observer, without a global clock, without a moment of stillness. This capacity for distributed self-awareness is one of the most remarkable properties of distributed systems, and the Chandy-Lamport algorithm is its foundational expression. The snapshot is not just an algorithm. It is a way of knowing — a way for a system to see itself, to understand itself, to tell its own story.