Tell us what works and what could be better. We read every submission.
@amirothman·11 public vizzes
This interactive WebGL visualization charts the 10,000 most frequent German nouns by rank, with each noun positioned by frequency and color-coded by its definite article (der/die/das). The nouns are rendered as a dense, scrollable strip or grid, where hovering or selecting a point reveals the noun, its rank, frequency, and the article(s) it can take. Data comes from the Leipzig corpora frequency ranking, with articles sourced from Wiktionary and der-artikel.de. The view also highlights ambiguous nouns and toponyms via annotations, letting readers explore how grammatical gender distributes across high-frequency vocabulary.
This example visualizes the complete internal tool architecture of Claude Code, showing how 30+ tools are organized into functional categories like file operations, execution, agent management, and IDE integration. The code uses a JSON schema to structure tool metadata, with each tool’s parameter schemas, error handling, and implementation behaviors documented. The visualization arranges tools by category and color-codes them by functional area, with detailed tool schemas rendered as expandable cards. The underlying data comes from a technical reference gist by amirothman, with layout handled through HTML/CSS flexbox and grid systems rather than a charting library.
Three circles are arranged on a dark background, each rendered as a solid colored disc that appears to drift and repel from one another. The visualization uses d3.forceSimulation to position the circles, applying collision and charge forces to create a subtle, organic motion. The code defines each circle’s radius and color, while the simulation updates their coordinates over time. Only the visible positions and interactions are shown, with no additional labels or axes.
This example shows a script that searches Twitter for tweets containing the query "TenagaNasionalBerhad" and prints each tweet’s text to the console. It uses the Tweepy library to authenticate with Twitter’s API via OAuth credentials and to perform the search. The code defines a `limit_handled` generator that catches `tweepy.error.TweepError` exceptions and pauses for 15 minutes before continuing, though the current script only iterates over a single page of search results without invoking that handler. The data source is Twitter’s live search endpoint.
This example demonstrates linear regression on a small dataset, plotting training and testing points to show the relationship between the input and output variables. The code uses NumPy arrays to store the data and computes a best-fit line, though the plotting itself is not shown in the provided snippet. The visualization would typically be rendered with a library like Matplotlib, displaying the data points and the fitted line to illustrate prediction accuracy. The dataset is explicitly defined in the file, with separate training and testing sets.
This visualization uses star coordinates to project LDA topic probabilities for news articles into a 2D scatterplot. Each document is positioned by summing its topic-probability-weighted axis vectors, where the 20 topic axes radiate evenly around an invisible circle. D3’s force simulation with collision avoidance gently nudges overlapping points apart. Points are colored by dominant topic and opacity encodes topic probability; hovering a point or a legend entry highlights all articles sharing that topic, enlarges them with an elastic ease, and displays the article title near the cursor. A second SVG renders an interactive legend of topics.
This example projects high-dimensional topic distributions onto a 2D star-coordinate scatterplot, revealing clusters of documents based on their topic probabilities. Each document is positioned as a weighted sum of topic-axis vectors, where ten topic IDs are arranged radially around a central origin. The code loads JSON data, computes axis positions using trigonometry, and sums topic probabilities times axis coordinates to place each point. It relies on D3 v4 for SVG rendering and data binding, with explicit coordinate calculations instead of layout algorithms.
The example demonstrates how the Polyglot natural language processing library detects and transliterates Malay text into English. It feeds a Malay-language news excerpt into the `Text` API, first calling `detect_language()` to confirm the language as Malay (`ms`), then applying `transliterate(target_language='en')` to convert each word into Latin characters. The output shows a word list where Malay terms like "parlimen," "pengarah," and "pilihan" are rendered phonetically in English, preserving their original pronunciation. The code relies on Polyglot's built-in language detection and transliteration functions, with the source text embedded directly in the notebook.
This example demonstrates a news crawler that fetches headlines from four Malaysian RSS feeds, extracts the full article text, and stores each story as a JSON file organized by publication date. The crawler uses `feedparser` to parse RSS feeds, `requests` to download article pages, and the `readability` library to isolate main content from HTML. `BeautifulSoup` cleans the extracted text, while `dateutil.parser` converts publication timestamps into structured day, month, and year fields. Each JSON file, saved in a local `collection` folder, contains the article’s cleaned content, original link, and parsed date components.
This example demonstrates filtering Atom feed entries by category using a StAX parser. It reads an XML file and extracts the text content of `<title>` and `<category>` elements, printing only titles whose category contains “HTML.” The code relies on the `javax.xml.stream` API, specifically `XMLInputFactory`, `XMLEventReader`, and `XMLStreamConstants`, to iterate through events. It handles `START_ELEMENT` cases to capture element text via `parser.getElementText()`, while skipping other event types. The data source is a local file path (`webtec.atom.xml`), and error handling uses a try-catch block that outputs any exception message.
This example demonstrates reading a newline-separated file into memory and writing it back out. The Go program uses the `bufio.Scanner` API to read each line from the source file "words9" and stores them in a slice, then prints each line with its index. It also writes the lines to "out.txt" using `bufio.NewWriter` and `fmt.Fprintln`. The code relies on standard library packages `os`, `bufio`, `fmt`, and `log` for file handling and error reporting.