SimilarExport ZIP

100%

Live Web links

✓ Published0🌍 Public

Last edited Oct 26, 2017

Created on Oct 26, 2017

This gallery example visualizes a live web link graph, mapping the relationships between news articles about the Equifax data breach, Catalonia’s independence movement, and breed-specific legislation. The visualization renders the connected URL nodes and edges in a force-directed layout, with each node’s position determined by the `d3.forceSimulation` API. The underlying data is sourced from a gist’s README file, which pairs original article links with corresponding Webrecorder archive URLs, allowing the view to compare live versus archived versions of the same story. The code uses the `d3.select` and `d3.force` methods to manage the interactive graph’s dynamics and layout, but does not include any custom panning, zooming, or filtering controls.

AI-generated description

Live Web links

Webrecorder links

Similar vizzes

Loading thumbnail…

Gist b287c640477b69e13e008ebfa52e8a86

This example shows a network graph of Linux-related articles and links, with nodes representing individual web pages and edges connecting them by shared references. The visualization uses a force-directed layout via `d3.forceSimulation` to position nodes, while the SVG rendering relies on standard D3 selections and `d3.forceLink` for edge constraints. Node color and size encode the source domain (opensource.com versus rootsudo.wordpress.com) and degree, respectively. The graph updates dynamically as the simulation runs, with drag interaction enabled through `d3.drag` for repositioning nodes.

Loading thumbnail…

Gist 7f84369bd0c0b467d6b0

This visualization uses a force-directed graph layout implemented with D3’s `d3.forceSimulation` to position nodes connected by links, representing a network of relationships from an underlying dataset. The scene renders on an HTML5 Canvas, with the simulation’s tick events redrawing the nodes as colored circles and the edges as lines. A zoom interaction is added via `d3.zoom`, applying a transform to the canvas context to allow panning and scaling of the graph. The example demonstrates a typical static network diagram without additional interactivity beyond zoom and drag, relying on the force simulation to settle the layout.

Loading thumbnail…

Gist a7d5ced57721ac3f7075bbbbaee32a49

This interactive visualization uses a force-directed simulation to animate a network of nodes and links, showing how connected elements cluster and repel. The code relies on D3’s `d3.forceSimulation` with custom forces for charge, centering, and collision, while link positions update via the simulation’s tick handler. Node rendering uses SVG circles, and the visualization reads its data from an embedded array of node and link objects, with no external data source. The interaction includes drag-and-drop support via D3’s drag behavior, letting viewers move nodes while the simulation continuously recalculates positions.

Loading thumbnail…

Gist 05ff2219cb2cc463ad1612e8a501c400

This visualization uses a force-directed simulation to show a network of interconnected nodes, with each node represented as a colored circle and links drawn between related points. The code relies on `d3.forceSimulation` and `d3.forceLink` to compute the layout, while `d3.drag` enables user interaction to move nodes. A canvas element renders the graph, with the simulation updating positions each tick. The data appears to be a small custom-generated dataset of nodes and edges, with node colors mapping to distinct groups, and the visualization does not include any external data source or geographic rendering.

Loading thumbnail…

Gist e899f735aa7a47c42f7b2604c713bfef

This example visualizes a force-directed graph using D3’s `d3.forceSimulation` to position nodes, with links drawn as SVG lines. The rendering approach uses Canvas `getImageData` to sample pixel data for a custom background effect, while Three.js handles 3D-like sphere rendering for node highlights. The code reads node and edge data from an embedded JavaScript object, and the simulation runs continuously with a `tick` handler updating node positions. A dropdown menu lets users filter the graph by cluster, though the filtering logic only updates node visibility without altering the underlying simulation forces.

Loading thumbnail…

Gist 1328c48d7adc70f7a23d190cdf877f7d

This visualization uses D3.js to render a dynamic network graph of interconnected nodes and links. The code employs `d3.forceSimulation` with forces such as charge, link, and centering to position the nodes, while links and nodes are drawn using SVG lines and circles. The simulation updates positions on each tick, and the graph responds to drag and zoom interactions. Node sizes and link thicknesses are determined by degree and connection counts, offering a clear view of the network’s structure and clustering.

Loading thumbnail…

Gist 27a5dee7d902d2ab3cf1281921ece401

This example visualizes a network of hyperlinks and page relationships extracted from a GitHub gist, mapping connections between referenced URLs and the gist itself. The code uses d3.forceSimulation to position nodes and d3.select plus SVG paths to draw curved links, with link opacity and node radius encoding connection strength and degree. The data is hardcoded as an array of source-target pairs, including links to resources like Cygwin and apt-cyg documentation. A drag handler enables interactive repositioning of nodes, while the simulation’s tick function updates the graph in real time.

Loading thumbnail…

Gist 6db8115f185f7e57cb4395da0474fbf6

This example presents an interactive visualization of a network graph, where nodes are connected by curved links and can be dragged by the user. The code builds the layout using `d3.forceSimulation` for physics-based positioning and renders the scene with `d3.select` and SVG elements, including `transition.attrTween` for smooth link animations. It reads a JSON dataset of node and edge data from an external file, and uses `d3.zoom` for panning and scaling the view. The visualization shows how force-directed algorithms distribute connected nodes while user input adjusts the simulation in real time.