Matt Dionis PGP Public Key

100%

Matt Dionis PGP Public Key

✓ Published0🌍 Public

Last edited Jul 6, 2017

Created on Feb 16, 2016

This visualization maps the characters of Matt Dionis’s PGP public key block, sourced from a gist, onto a circular force-directed layout. Each line and character from the key is rendered as a node or link, with the structure of the ASCII-armored text made visible through spatial clustering. The sketch uses `d3.forceSimulation` to position nodes, while a Canvas 2D context draws the characters and connectors, revealing patterns in the key’s base64 content and its header/footer metadata. The layout emphasizes the block’s internal rhythm and length.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 70625

This example visualizes a force-directed graph built with the D3.js library, using `d3.forceSimulation` to compute the layout. The graph’s nodes are rendered as text labels on an HTML5 Canvas, where each label displays a single character from the Gist’s source code. The visualization shows the spatial clustering of these characters, and the code calculates how many times a given character appears in a node’s adjacency list using a custom `f(ra,n)` method. The rendering approach relies on Canvas’s `fillText` for drawing labels, with the simulation updating positions each tick.

DDylanFM

68% match

Loading thumbnail…

Gist 1967223

This example visualizes the leaked plaintext password from a support email, mapping its characters and their positions through a network layout. The code uses `d3.forceSimulation` to arrange character nodes, with `d3.geoPath` absent; instead, it employs SVG paths for links and `transition.attrTween` to animate text placement. The data comes from the email’s body, parsed into individual characters and spaces, while the rendering approach highlights the password’s structure as a force-directed graph. Only the visible simulation and tweening logic appear, with no additional interactions beyond the animated layout.

CCaged

66% match

Loading thumbnail…

Gist 9e2ff3789a2158f045441b8f90f7ab91

This example visualizes the content of an encrypted message by decoding its PGP structure. It shows the raw cryptographic payload, including the key ID, version, and comment metadata, as a series of text blocks. The visualization uses the `d3.select` and `d3.text` APIs to fetch and display the message content, with a focus on the Base64-encoded body. It highlights the header lines (e.g., "Version:" and "Comment:") separately from the encrypted data, rendering them as distinct styled sections. The source is a static gist file, and the rendering relies on plain HTML and CSS, not on interactive libraries.

CCliffordAnderson

66% match

Loading thumbnail…

Gist 8a97689739c217f28474d80c89013628

This visualization uses a force-directed graph to show relationships between entities, with nodes positioned by `d3.forceSimulation` and links drawn as curved paths. The code computes node sizes and colors from quantitative attributes, while a canvas overlay via `d3.geoPath` and `getImageData` samples pixel density to modulate link opacity based on local clustering. It employs a custom `transition.attrTween` to animate node drift when the simulation restarts, and uses the `d3.hierarchy` API to flatten nested data from a JSON file. The visualization reads credentials from an `env.list` file for a private data source, but the rendering logic is independent of that authentication step.

CConorAspell

64% match

Loading thumbnail…

Message for Veronca

A PGP-encrypted message from Clifford Anderson is displayed as a force-directed network visualization, mapping each character of the ciphertext to a node. The layout uses d3.forceSimulation with collision and link forces to separate and connect the text, while the encrypted payload’s structure emerges as clusters. The code parses the ASCII-armored message and renders it with SVG circles and paths, using d3.zoom for pan and scale. The rendering approach converts the raw text into a visual graph, revealing patterns in the otherwise opaque encrypted data.

CCliffordAnderson

64% match

Loading thumbnail…

MIT-License

This visualization uses a physics-based simulation to cluster and connect nodes in a network. It shows a dynamic system of points that repel each other while links pull them together, creating an organic, ever-shifting layout. The code leverages d3.forceSimulation to model the forces and d3.geoPath for rendering the curved edges. Built on a gist of public data, the example demonstrates real-time interaction with the simulation, offering a clear view of how force-directed algorithms explore spatial arrangements.

11wheel

64% match

Loading thumbnail…

Message for Lindsey

This example demonstrates how encrypted text can be visualized as a static PGP message block, rendering the raw ciphertext characters with monospaced typography. The visualization uses the d3.js library to lay out the message’s lines and characters, applying a simple grid-based positioning system to preserve the original message structure. The data source is a Keybase OpenPGP-encrypted text file containing a private message intended for a specific recipient, which the code parses and displays without attempting decryption. The rendering approach relies on standard SVG text elements positioned via d3’s coordinate mapping functions.

CCliffordAnderson

64% match

Loading thumbnail…

Blocks Graph

The visualization shows a force-directed network of 1,238 bl.ocks examples, with nodes representing individual gists colored by author and links indicating mentions between README files. The network layout is computed using `d3.forceSimulation` with many-body charge, link, and position forces, and rendered directly to a Canvas `getContext("2d")` surface. Nodes are drawn as small circles with a 3-pixel radius, and hovering reveals a link to the original bl.ock, while dragging interactively repositions nodes. The data is a cleaned subset of Micah Stubb’s May 2016 dataset, filtered to remove missing and redundant entries.

Mmbostock

64% match