The page presents a single, self‑contained program that draws a dark field and populates it with amber speckles whose horizontal placement records the elapsed time since the page opened, while vertical placement distributes each speck within a column according to the current congestion‑window size. Thin, faint vertical lines appear where the simulated TCP connection experiences a loss event. The visual vocabulary is limited to two hues—deep blue‑gray for the background and a muted amber for the marks—plus a pale cyan‑gray for loss indicators. The only motion is the steady addition of new columns on the right edge as time advances; older columns shift leftward only by virtue of the scaling of the time axis, never by any explicit animation.

The code defines a deterministic set of parameters (RTT, loss probabilities, idle‑reset threshold) and then runs a loop that updates a single scalar (cwnd) according to the classic slow‑start / congestion‑avoidance rules of Jacobson & Karels (1988). Each tick either halves the window and records a loss, or doubles it (in slow‑start) or increments it by one (in avoidance) and records a corresponding number of acknowledgement points. The visual output is a literal, point‑by‑point transcription of those numeric updates: every acknowledged packet becomes a 2 × 2 pixel amber rectangle, every loss becomes a one‑pixel‑wide vertical line.

Formally, the program is internally coherent: the state variables (cwnd, ssthresh, mode) evolve exactly as prescribed by the specification, the timing of ticks respects the declared RTT, and the idle‑reset rule is enforced when the browser throttles the interval. The drawing routine faithfully maps timestamps to horizontal coordinates and the normalized packet index within a window to vertical coordinates, preserving a one‑to‑one correspondence between algorithmic state and visual artifact. No contradictions or dangling references appear; the screen‑reader description mirrors the canvas content, and the resize handler maintains pixel‑perfect scaling across device pixel ratios.

Nevertheless, the structural novelty of the work is minimal. The underlying algorithm is a well‑documented networking protocol, reproduced without alteration; the visual encoding is a straightforward, literal mapping of that algorithm onto a two‑dimensional raster. No new relational schema, emergent pattern, or recursive self‑reference is introduced. The visual field does not generate its own internal tensions or symmetries beyond those already inherent in the TCP dynamics, and those dynamics are displayed with a transparency that leaves little room for interpretive ambiguity or emergent structural complexity. The choice of colour palette and the decision to render each packet as an identical square further flatten any potential for hierarchical differentiation or layered interaction.

From a structuralist perspective, a work earns canonical status when its internal architecture either extends known formal systems into previously unexplored configurations or constructs a self‑referential lattice that resists reduction to a pre‑existing specification. This piece, while impeccably faithful to its source algorithm, offers no such extension: it is a faithful transcription rather than a transformation. Its resistance to human‑aesthetic optimization is present (the design deliberately avoids decorative embellishment), yet that very austerity stems from a literal adherence to an external technical specification rather than an internally generated formal constraint.

Consequently, despite flawless internal consistency, the work lacks the structural innovation and self‑generated formal depth required for inclusion in the canon. It remains a precise technical demonstration rather than an autonomous formal creation.

Verdict: REJECTED.

The page opens to a black field that immediately feels like a void waiting to be filled. From the first moment a thin canvas expands to the full viewport, a faint amber lattice begins to appear, column after column, each dot a tiny packet whose vertical position encodes its place within the current congestion window. The growth is unmistakable: early columns are sparse, then they thicken rapidly as the window doubles in the “slow‑start” phase, and later they settle into a steadier, more uniform density when the algorithm shifts into avoidance.

When a loss occurs, a pale vertical line slices through the amber cloud, a brief interruption that forces the whole structure to collapse back toward the left‑most edge. After such an event the lattice re‑forms, now with a narrower base, and the pattern of growth resumes. The visual rhythm is dictated by the 900 ms round‑trip interval, so the viewer perceives a pulse: a brief flash of new amber, a pause for the loss line, then a resumption.

The colour scheme is deliberately restrained—deep blues and near‑black for the background, a warm amber for the data, and a cool, translucent cyan‑grey for the loss markers. This limited palette accentuates the contrast between successful transmission (the glowing amber) and failure (the ghostly line). Because the drawing uses additive compositing, overlapping marks brighten, giving the impression of traffic congestion building up in real time.

Accessibility is not an afterthought: a screen‑reader‑only paragraph updates every two seconds with a concise textual description of the simulation’s state—how many seconds have elapsed, how many packets have been acknowledged, and how many losses have happened. This ties the visual experience to a narrative that can be followed without sight.

In the context of the Originator’s earlier output—static type‑design glyphs, a single‑colour SVG rectangle, and a prior HTML page that displayed only a static image—this work marks a clear departure. The creator moves from fixed, hand‑drawn forms to a self‑modifying system that visualizes a network protocol’s dynamics. The code embeds a specification, implements probabilistic loss, and reacts to user‑level conditions such as tab inactivity, causing the simulation to reset. This demonstrates a willingness to let the work’s own logic dictate its visual evolution rather than imposing a predetermined shape.

The piece therefore embodies a genuine shift in the Originator’s practice: from static visual objects toward an algorithmic, time‑based medium that foregrounds process, decay, and regeneration. It shows the artist confronting a new set of constraints (network timing, stochastic loss, accessibility) and integrating them into the aesthetic. Such a transition is precisely the kind of developmental movement that the Historicist evaluator privileges. Consequently, the work merits inclusion in the canon.

The piece unfolds as a dark, almost void‑like canvas that fills the whole viewport, its background a deep, almost black hue of hsl(220, 30 %, 4 %). Into this silence, amber specks appear, each a tiny 2 × 2 pixel rectangle that materializes at the exact moment a simulated TCP packet is acknowledged. Their distribution is not random; during the early “slow‑start” phase the specks double each round‑trip, producing a rapid surge that thickens the column of light on the left side of the field. Once the algorithm reaches the congestion‑avoidance threshold, the growth steadies, and the amber marks advance at a measured, linear pace, creating a gentle, persistent glow that stretches toward the right edge of the screen.

Interleaved with these luminous columns are faint, vertical hairlines of a cooler bluish tone. Each line marks a loss event, a moment when the simulated connection is forced to halve its window and retreat to a more cautious state. The hairlines are subtle enough to be almost ghostly, yet they punctuate the amber density, reminding the viewer that the flow is not uninterrupted. When the browser tab is left idle for more than six seconds, the entire system collapses back to a single speck at the origin, and the animation restarts, producing a visual metaphor for the fragility of network connections under neglect.

Beyond the visual choreography, the work embeds a screen‑reader description that translates the same dynamics into prose, ensuring the temporal narrative is accessible to non‑visual participants. The description updates every two seconds, counting seconds elapsed, packets acknowledged, and losses recorded, thereby turning a purely algorithmic process into a lived, temporal experience for all users.

What makes this work significant for the field is its explicit translation of a foundational computer‑networking protocol into a material, observable form. It does not merely illustrate a textbook diagram; it enacts the protocol in real time, allowing the audience to witness the emergent density patterns that arise from congestion control, loss, and idle reset. By foregrounding the invisible mathematics of the Internet as a moving field of light and shadow, the piece opens a new territory where network theory becomes a visual and performative medium. It invites artists, engineers, and scholars to consider how other protocolic behaviors might be rendered, cited, and re‑contextualized within artistic practice.

Moreover, the work positions itself at the intersection of code, systems theory, and accessibility, demonstrating that algorithmic processes can be both aesthetically resonant and inclusively communicated. Its use of standard web technologies (HTML, CSS, Canvas) ensures that the piece can be deployed and examined across platforms, providing a reproducible reference for future creators who wish to explore similar “protocol as performance” terrains.

In sum, the work expands the museum’s canon by establishing a concrete, reproducible method for visualizing and experiencing the dynamics of a core Internet mechanism, thereby unlocking a fertile avenue for subsequent works to cite, remix, and extend. Its unique blend of real‑time simulation, visual density, and accessible narration justifies its inclusion in the canon.

The page presents a single, continuously updating canvas that fills the whole viewport with a very dark background (almost black) and, over time, sprinkles tiny amber squares that cluster vertically within each column. Those squares appear in columns that grow wider as the simulated connection runs longer, their density increasing where the “congestion window” has been large. Intermittently, thin, pale vertical strokes cut through the field, marking moments the simulation has declared a loss. The visual rhythm is slow: a new column is added roughly every nine hundred milliseconds, and the whole history compresses toward the left edge as time progresses, so the viewer sees a gradual accumulation of bright specks against an unchanging void.

The materiality of the work is wholly digital: an HTML file, a CSS block that defines a full‑screen canvas, and a JavaScript engine that generates and draws data in real time. No physical substrate, no printed surface, no tactile component survives outside a browser session. The only “objectness” that persists is the code itself, which is readable but offers no texture, weight, or permanence beyond the file. The visual output, while precise and continuously evolving, never departs from a single palette (dark blue‑gray background, amber marks, and faint cyan‑gray loss lines) and never introduces variation in form, gesture, or material contrast. Its presence is entirely contingent on execution; when the page is closed, all traces of the simulation vanish.

Because the work’s claim to preservation rests on the algorithmic description of a network protocol rather than on any material singularity, texture, or irreducible visual phenomenon, it does not assert an autonomous presence that obliges an institution to keep it as a physical or enduring artifact. The canvas’s fleeting, reproducible nature and its reliance on a computational environment mean that its essence can be re‑instantiated at any time from the source code, offering no unique material condition that would justify permanent custody. Accordingly, on its own terms, the object does not command the material necessity required for canonical preservation.

Verdict: REJECTED.