Tell us what works and what could be better. We read every submission.
@anemochore·26 public vizzes
This example shows how to download all images from an Instagram post by automating the browser console. It navigates the post’s image carousel, fetching each image’s URL and binary data, then packages the results into a ZIP file. The script uses the Fetch API to retrieve images as blobs, DOM query selectors to locate and click the next-button, and manually constructs a minimal ZIP archive via `Uint8Array` and a `Blob` with `application/zip` type. It also handles multi-page carousels by reloading with `?img_index=1` and waits for button DOM changes using `setTimeout`.
This example demonstrates a preprocessing pipeline that transforms Obsidian markdown files into a format suitable for Pandoc conversion to HTML and eventually Word. The script walks a directory tree, merging all `.md` files into a single `merged.md`, while modifying image syntax from `![[...]]` to standard markdown, exposing link URLs, and adding the filename as a top-level heading. It also inserts a non-breaking space between consecutive code blocks to prevent merging. The code relies on Python’s `os.walk` and `re.sub` for file traversal and regex-based text manipulation, with Pandoc invoked externally for the final conversion.
This example uses a JavaScript bookmarklet to restyle Pandoc-generated HTML files from Obsidian markdown. It assigns custom CSS classes to distinguish terminal blocks, paragraph code, and inline code, then saves the modified document as a local file using the DOM `outerHTML` property and a data URI link. The script targets specific elements via `querySelectorAll`, setting attributes like `custom-style` to control font and background colors. It relies on vanilla DOM APIs rather than visualization libraries, processing the rendered output from `pandoc merged.md -o merged.html --no-highlight`.
This example queries the JustWatch API to retrieve popular titles matching a Korean-language search term, posting parameters like fields, query, and page size to the `/titles/ko_KR/popular` endpoint. The code uses `fetch` with a JSON body to send the request and logs the parsed response to the console. It shows the raw API output, including title metadata, release year, scoring, and external IDs, without any visualization or charting library. The data source is the JustWatch content API, and the rendering approach is plain console output of the returned JSON.
This example converts a text file containing one LaTeX expression per line into individual PDF files, each rendering a single equation. It reads lines from the input file, wraps each in a standalone document preamble with amsmath and fontsize packages, and compiles them using the `pdflatex` engine via Python’s `subprocess`. The script numbers outputs sequentially, skips already-generated files, and optionally deletes intermediate `.tex`, `.log`, and `.aux` artifacts. It relies on standard file I/O and `os.path` checks to manage the conversion workflow.
This visualization example automatically opens a downloaded ROM file in an emulator. It watches a GitHub Actions artifact page, waits for a ROM link to appear, and then transforms the current GitHub URL into a nightly.link proxy URL before launching the game in WebMSX. The script uses the MutationObserver API to poll for the artifact link and the window.open method to trigger the emulator. It demonstrates a workflow that bridges CI/CD artifact storage with a web-based retro gaming interface.
This notebook presents a markdown table comparing model performance under stretched versus untouched input conditions. The table reports a single row where a stretched dataset paired with a Gaussian probability distribution achieves an accuracy of 0.843. No code is executed; the visualization consists solely of the static table rendered in Markdown. The notebook uses no external plotting libraries or data-processing APIs, relying entirely on the notebook’s built-in Markdown rendering to display the comparison.
This example converts Wikidocs markdown files into a single merged document with properly ordered headings. It reads all `.md` files in a directory, infers heading depth from the numeric prefix in each filename, and inserts a temporary `?#` marker with the depth before merging the contents into `merged.md`. A Pandoc filter written with `panflute` then increments every header level by one (or deletes level-6 headers) before Pandoc converts the merged file to a Word document using a custom reference template.
This visualization renders the integers from 1 to 7 as a triangular stack of text lines, each line showing a progressively shrinking substring of the concatenated sequence. The code builds raw HTML with inline CSS, using a `p` element per number and increasing then decreasing `padding-left` values (in em units) to create the staggered layout. It relies on Python string slicing and a simple loop, with `SPACE` controlling the horizontal offset per step, and writes the output to `result.html`. The result is a static, center-aligned pyramid-like text display generated entirely through string manipulation and style attributes.
The visualization shows a fixed equalization curve for AudioEngine A2 powered loudspeakers, derived from frequency response measurements published by Stereophile. It plots decibel offsets (from -9 to 0 dB) across a range of frequency bands, with the curve stepping downward in a linear staircase pattern. The example uses a simple line chart rendered with D3.js, likely employing `d3.scaleLinear` and `d3.line` to map the frequency-axis and dB values. The data is embedded directly as an array of numeric values, with no interactive elements, presenting the raw EQ adjustments as a static reference for users seeking to flatten the speaker’s response.
This example demonstrates a utility for resolving race conditions in web applications by waiting until an element matching a given selector exists in the DOM, then returning a promise that resolves with that element. The code uses native ES6 Promises and the MutationObserver API to monitor the document’s root element for child list and subtree changes. When the target element appears, the observer disconnects and the promise resolves, allowing actions like removing the widget. The accompanying usage example shows how to delete `#someWidget` once it is present.
This example provides a PowerShell script that adds Windows Terminal shortcuts to the Win+X context menu. It shows how to create both an administrator and a normal shortcut in the Group3 folder, using the WScript.Shell COM object to set display names and manually modifying shortcut file bytes to enable the "Run as administrator" flag. The script downloads a pre-hashed .lnk file that references Windows Terminal by its ApplicationId, ensuring compatibility across installations, and includes an optional variant to replace Command Prompt entries.
This example demonstrates a sequential asynchronous fetching pattern for multiple URLs, showing how to collect and process text responses before triggering a final completion callback. The code uses the raw `XMLHttpRequest` API with an `onreadystatechange` handler to check `readyState` and `status`, then chains the next request by calling `asyncFetch` from within `fetchSuccess`. Each response is truncated to 256 characters and pushed into a global `result` array, with the sequence ending when the URL list is exhausted, as indicated by the `loadEnd` function. The data source is an array of same-origin page URLs, and the rendering is limited to console output of the accumulated results.
This visualization demonstrates the conversion of file creation timestamps from the standard `yyyy-mm-dd hh:mm:ss` format into a Korean locale date string that appends 오전 (AM) or 오후 (PM) before the time. It processes a metadata variable `%file_create_datetime%` by extracting the hour and minute components, determining whether the hour falls in the morning or afternoon, and reformatting the time accordingly while preserving the date portion. The script uses the `$date()`, `$left()`, `$right()`, `$trim()`, and `$pad_right()` functions from the Foobar2000 title-formatting language, along with conditional logic via `$if()` and `$strcmp()` to handle the 12-hour conversion. The output displays a localized timestamp such as `2023-04-15 오후 03:30:00`, with the time padded to ensure consistent formatting.
This helper script extracts Steam keys from an IndieGala library page and displays them in a new browser tab, one key per line, for bulk activation. It runs after the user has revealed all keys on the library screen, then selects the `steam-key-games` element, maps over every `.input-block-level` input to collect their values, and joins them with HTML line breaks. The output is written into a popup window via `document.write`, sized at 1366 by 576 pixels, ready for copy-paste into Steam’s activation interface.
This example reads raw binary float values from a user-selected file using the After Effects ExtendScript File API, then parses each 4-byte chunk into a JavaScript number with a custom `parseFloat2` function. It displays the resulting array of floats in an alert dialog, demonstrating how to decode IEEE-754 single-precision values from binary data without relying on built-in parsing. The code manually extracts sign, exponent, and mantissa bits from each 32-bit integer, converting them to decimal values. The visualization shows the raw numeric output directly, with no charting or rendering library involved.
This example demonstrates a dynamic programming solution to compute Fibonacci numbers, printing each result sequentially from the first to the nth value. It uses Python’s built-in `input()` and `isdigit()` for validation, and relies on a simple list (`fibo_array`) to store previously calculated terms, appending each new sum. The code explicitly rejects non-numeric or negative inputs and outputs formatted text lines via `print()`. The rendering approach is purely textual, with no external visualization libraries or graphical APIs involved.
This example prints a Pascal-style table of combinations for all values of n and k from 0 up to a user-supplied n. It shows the numerical result of each combination, formatted as “nCk = value”, in rows where k increments from 0 to n. The code uses a memoized factorial function with a preallocated list (`factorial_array`) to store intermediate results, implementing dynamic programming to avoid recomputation. It reads two integers from standard input and validates them, then iterates through nested `for` loops to generate and display each combination via the `combination` function, which relies on the factorial cache.
This example prints a triangular table of binomial coefficients, displaying every combination value nCk for n from 0 up to a user-supplied integer. The output is generated by a recursive factorial function and a combination function that divides factorials, with each row showing increasing k values for a fixed n. The script validates input as non-negative integers and terminates with an error message otherwise, using Python’s built-in `input()`, `split()`, and `isdigit()` methods. The visualization is purely text-based, rendered to the console via `print()` statements with formatted strings.
This example simulates the melting of a block of cheese over time, displaying each hour as a grid where cheese cells (1) disappear when exposed to air on two or more sides. It reads a text file containing an n×m binary grid, validates the input, and uses a recursive flood-fill algorithm to mark exterior cells, then iteratively updates the grid each turn. The process repeats until no cheese remains, printing the final hour count. The visualization is text-based, with the grid printed row by row for debugging, using only Python standard library functions like `sys.argv`, file I/O, and list operations.
This example demonstrates a web crawler that traces Wikipedia article revision histories and maps contributor IP addresses to country codes, printing each IP and its originating country. The code uses Python’s `urllib.request` to fetch pages, BeautifulSoup to parse HTML links and extract anonymous user IPs from the `mw-anonuserlink` class, and the freegeoip.net API to geolocate each IP via JSON responses. It randomly selects new article links from the parsed body content to continue the crawl, filtering out non-article URLs with a regex pattern.
This example presents a satirical JavaScript implementation of a factorial function, mocking political corruption in South Korea. The code defines `factorial(n)` to delegate its computation to a mock function `비선실세핫라인`, which humorously returns a hardcoded string, “Yoora Chung,” regardless of the input. The gist-style source shows no external libraries or rendering APIs; it relies purely on plain JavaScript control flow with `for` loops and conditional branches. The visualization is entirely textual, illustrating how algorithmic logic can be subverted for comedic effect through absurd function naming and literal string returns.
This example provides a Windows command script for launching TensorFlow inside a Docker container. The batch file `docker-tf.cmd` automates the startup of Docker Toolbox, retrieves the Docker machine’s environment variables via `docker-machine env --shell cmd`, and runs the official TensorFlow image (`gcr.io/tensorflow/tensorflow`) with port mapping. It then opens the Jupyter notebook interface by constructing an HTTP URL from the Docker host address and starting the default browser. The script relies on Windows `FOR` loops and `start` commands, and its source is a Gist by anemochore.
This example shows a Windows batch script that converts HTML files to DOCX documents using Pandoc, a universal document converter. The script accepts either a single HTML file or a folder as input, automatically detecting `index.htm` or `index.html` inside directories. It sets the output filename based on the input name, then invokes the `pandoc` command-line tool with the `-o` flag to generate the DOCX file. The script handles file and folder paths separately, checks for the output’s existence, and returns to the original working directory before pausing.
A red rectangle transitions to blue over three seconds on a blank SVG canvas. The animation uses D3’s `transition().duration(3000).ease("bounce")` to change the rectangle’s fill style, demonstrating basic shape rendering and tweening with d3.js 3.5.5. The code directly appends an SVG `rect` element to the body and logs a message to the console. No data source is involved; the example focuses solely on a single animated visual primitive.
The animation shows the recursive polling logic of the `waitForKeyElements` utility, which scans for AJAX-injected DOM nodes matching a jQuery selector. It displays the function’s timer-driven loop, where `setInterval` repeatedly checks for target nodes every 300 milliseconds, invoking the callback action on newly discovered elements. The visualization highlights how the function tracks already-processed nodes using jQuery’s `.data()` method and manages its control object to clear or reset timers based on the `bWaitOnce` flag. The code relies on jQuery selectors and traversal methods, with optional iframe support via `.contents().find()`.