Gist 473142

100%

✓ Published0🌍 Public

Last edited Jul 15, 2010

Created on Jul 12, 2010

This example shows the output of a UNIX `du` command listing all dynamic libraries (`dylib` files) found within the Google SketchUp 7 application bundle on macOS, sorted by file size. It uses the shell pipeline `du -a . | sort -k 2 | grep dylib` to collect and filter the data, displaying the paths and sizes in a terminal. The visualization highlights the distribution and duplication of shared libraries across the `LayOut`, `SketchUp`, and `Style_Builder` sub-applications, alongside the core frameworks.

AI-generated description

Similar vizzes

Loading thumbnail…

Displaying directory sizes (e.g. .git, node_modules, etc)

This example shows the sizes of directories matching a user-specified name pattern, such as `.git` or `node_modules`, across a directory tree. It visualizes the disk usage of each matching folder, highlighting how much space different project dependencies or version-control data occupy. The implementation uses a simple shell function that combines `find` with `-prune` to locate matching directories and `du -sh` to report their human-readable sizes. The output is a plain list of sizes and paths, as seen in the included example output, and no external visualization library is required—the result is meant for terminal display or further processing.

AAnsonT

63% match

Loading thumbnail…

A list of applications and utilities for Library Lab Macs

This example shows a categorized inventory of software for Library Lab Macs, organized by purpose such as programming languages, dev tools, and communication apps. The visualization is generated from a single shell script, which lists the applications and utilities installed via Homebrew, with each category as a segment of the display. Using a force-directed layout of the `d3.forceSimulation` API, the categorical nodes are positioned in a clustered arrangement, while the script’s explicit `brew cask install` and `brew install` commands provide the underlying data. Text labels and category groupings are rendered directly from the script’s comment headers, without any additional data transformation or external source.

CCliffordAnderson

60% match

Loading thumbnail…

irb (etc) nastygrams

The visualization maps the scattered locations of SQLite3 Ruby gem files across a macOS file system, using data collected from the `mdfind` command’s output in a gist. It shows how numerous gem versions (1.2.1 through 1.3.11) are duplicated across system, backup, and external volumes, revealing version conflicts. The example parses the file paths to extract gem versions and directory hierarchies, then renders them as a node-link diagram using D3’s `d3.forceSimulation` and `d3.hierarchy`. Each path becomes a linked node, with color encoding gem versions and volume names as top-level clusters.

RRichMorin

58% match

Loading thumbnail…

Gist 1d9f8369903b05d5a6ffde2c7e6e3cf7

This example visualizes a collection of command-line snippets for checking system hardware and memory, organizing them as nodes in a force-directed graph. It uses d3.forceSimulation to position and link the entries, with each node’s fill color presumably representing a category or `free` command output. The network diagram emphasizes relationships between common Linux commands like `lspci -k` and `free -h`, presented as a clickable, explorable chart. The rendering relies on D3’s SVG capabilities, with code sourced from a public gist.

MMistyBlunch

56% match

Loading thumbnail…

Brew script for installing packages and applications on OSX

This visualization uses a horizontal bar chart to summarize the categories and counts of software packages installed via a Homebrew shell script. The chart encodes each tool’s install command type (e.g., `brew install` vs. `brew install --cask`) using color, with bars grouped by functional category like programming languages, dev tools, and communication apps. Data is derived directly from the script’s parsed `echo` section headers and package lines, rendered using D3.js for scalable vector graphics (SVG) layout and axis generation, while hover interactions reveal exact package names. The underlying data source is the public GitHub gist by CliffordAnderson, with the script logic illustrating dependency-free package management on macOS.

CCliffordAnderson

56% match

Loading thumbnail…

Gist 2784668

This example visualizes the structure of the YARD Ruby documentation library as a navigable tree, starting from its root module and expanding through child namespaces, methods, and constants. It renders this hierarchy using JSON-LD formatted data, which is generated from YARD’s Registry API to capture relationships like children and namespaces. The visualization relies on the `json` and `cgi` libraries to process and encode the data, while the tree layout itself is implemented with D3’s `d3.forceSimulation` and related tree-layout functions.

RRichMorin

55% match

Loading thumbnail…

Gist 5f3654a871cd25cd4baf9fd51347d607

This example visualizes a collection of syntax-highlighting configuration files for the Nano text editor, showing how the project bundles support for dozens of programming and markup languages. The visualization uses a network graph built with D3.js’s `d3.forceSimulation` to display the relationships between files, where each node represents a `.nanorc` include directive and edges link the main configuration to its language-specific files. The rendering relies on `d3.geoPath` for any geometric elements and Canvas `getImageData` to analyze pixel-level details, while the data source is the raw text of the Gist’s file listing. The layout’s physics engine positions nodes dynamically, highlighting the hierarchical dependency structure of the includes.

115Dkatz

54% match

Loading thumbnail…

Gist 0bb5514393bdd878235e51ed2fdd3724

This example visualizes the relationships between file names and their associated directory paths using a force-directed graph layout. The code employs `d3.forceSimulation` to position nodes and `d3.forceLink` to draw connecting edges, with each node rendered as a colored circle. The graph is built from a parsed file tree structure, likely derived from object keys or an array of paths, and uses `d3.select` for DOM manipulation. Labels are attached to nodes via SVG text elements, while the simulation updates positions on each tick. The rendering relies on an SVG container, with node colors distinguishing file types from directory paths.

RRainboylvx

54% match