Skip to main content
Log in
F

Frozenfire92

@Frozenfire92·21 public vizzes

Loading thumbnail…

A random dungeon generator that fits on a business card

This example renders a procedurally generated dungeon map as ASCII art in a terminal, using a random cave-growing algorithm. It shows a 40-by-80 grid of wall and floor tiles, with occasional doorways, gold, and a starting position marked by `@`. The generator, written in C, uses the standard library’s `rand()` for all stochastic decisions, and draws its output via `printf` and `putchar`. The code fits on a business card, implementing the entire simulation in a single compressed source file.

Mar 2, 2019
Loading thumbnail…

SCRIPT-8

SCRIPT-8 is a canvas-based game cassette that runs a simple interactive program written with the SCRIPT-8 engine. It renders a small scene using the engine’s built-in drawing commands and updates it each frame through its game loop. The code uses SCRIPT-8’s `tick` callback to handle input and time, and employs its `sprite` and `map` APIs to place graphics on the screen. The visible result shows a basic character or object moving in response to keyboard controls, with the entire experience contained in a single `code.js` file. No external libraries are used beyond the SCRIPT-8 runtime.

Jan 26, 2019
Loading thumbnail…

SCRIPT-8

This example uses SCRIPT-8, a JavaScript fantasy console for creating retro-style games and visualizations. It renders a colorful, animated scene directly to the canvas using the console’s built-in graphics API. The visualization draws sprites and map data from JSON files, with procedural animation driven by the `requestAnimationFrame` loop. SCRIPT-8’s `pixel` and `sprite` functions handle the drawing, while its input and sound APIs are loaded but unused, focusing purely on visual output. The cassette’s empty chains, songs, and phrases files confirm a minimal, self-contained demonstration of the platform’s rendering capabilities.

Jan 26, 2019
Loading thumbnail…

SCRIPT-8

This example shows a minimal SCRIPT-8 cassette program that renders the text "Hello world!" on a virtual pixel display. The entire visualization is defined in a single `code.js` file using the SCRIPT-8 runtime, where a `draw` function calls the built-in `print` method to place text at coordinates (42, 60). The accompanying metadata files—`chains.json`, `map.json`, `phrases.json`, `songs.json`, and `sprites.json`—are all empty, indicating no additional assets or logic. The rendering approach relies entirely on SCRIPT-8’s canvas-based API, with no external libraries like d3 or Three.js involved.

Jan 26, 2019
Loading thumbnail…

TestBug

This example demonstrates an interactive select dropdown component built with Ember.js. The component, defined in `components.select-dropdown.js`, maintains a bound `value` property and synchronizes it with the selected `<option>` element using observers and the `didRender` lifecycle hook. It supports plain string arrays or objects with `value` and `label` keys, with an optional empty default option. The application controller supplies a static `dropdownOptions` list, and the template renders the dropdown with a bound selection. The code relies on Ember’s component lifecycle methods (`didReceiveAttrs`, `didInsertElement`, `didRender`) and the `change` event handler to propagate user selections back to the controller.

Jul 18, 2018
Loading thumbnail…

Install Scala and SBT using apt-get on Ubuntu 16.04 or any Debian derivative using apt-get

This example presents a shell-script sequence for installing the Java Development Kit, Scala, and the Simple Build Tool on Ubuntu 16.04 or Debian-based systems via `apt-get`. It combines `sudo apt-get` commands, `wget` to fetch a Scala `.deb` package, and `dpkg -i` for manual installation, followed by adding an SBT repository and importing its GPG key via `sudo apt-key`. The code relies on system package managers and command-line tools.

Feb 5, 2017
Loading thumbnail…

Alternative Calendar View

This alternative calendar heatmap displays the daily percentage change in the Dow Jones Industrial Average (DJI) from Yahoo Finance, where each day is a colored cell. Unlike the original D3 calendar layout, it arranges multiple months per row to better suit data spanning a few years. The visualization uses D3 version 3 to render SVG rectangles, with tooltips for hover details. A quantized color scale applies an RdYlGn color scheme, and the layout includes month and year labels.

Dec 29, 2016
Loading thumbnail…

Gist 8b0da6e9acc76b7251547a0ad1dad5f1

This shader example demonstrates a technique for snapping pixel-art sprites to a fixed pixel grid in a 3D game engine. It shows how vertex positions are aligned to integer multiples of a tunable “pixels per unit” value prior to rendering, preventing visual distortion or shimmering when sprites are placed in world space. The code is written for Unity’s proprietary shader language and uses a Cginc/UnityCG-style vertex and fragment program, aligning object-space vertices before passing them through the standard MVP matrix. The shader samples a main texture and optionally an external alpha texture, tinting the result with a `_Color` property.

Oct 4, 2016
Loading thumbnail…

Sequential execution of Promises using reduce()

This example demonstrates sequential execution of asynchronous Promise chains in JavaScript. It shows how the `reduce()` method orchestrates a collection of async tasks so each completes before the next begins, producing an ordered final result. The code uses native JavaScript Promises, the `Promise.resolve()` initializer, and `setTimeout()` to simulate time-based async work. The data source is the hardcoded array `[1, 2, 3]`, with each item’s delay proportional to its value. The rendering is purely console-based, logging each step and the final accumulated array via `console.log`.

May 26, 2016
Loading thumbnail…

Gist 95588bd77669e425eaccc173d60db0ea

This example visualizes the concept of turning off GitHub issues, using a force-directed graph rendered with d3.forceSimulation. Nodes represent maintainers, contributors, and pull requests, with links showing the flow of feedback through pull requests instead of issues. The layout is computed dynamically as the simulation runs, with node positions and link paths updated each tick. The data comes from a static JSON array embedded in the code, and the visualization highlights the argument that pull requests, not issues, should be the primary interaction channel.

Mar 17, 2016
Loading thumbnail…

keyPress vs Up

This example demonstrates the sequence and difference between the `keyPress` and `keyUp` browser events as they fire while typing in a text input field. It uses an Ember component with a template containing an `{{input}}` helper, and the component's JavaScript defines handlers for both events that log the corresponding `keyCode` to the browser console. The data originates from user keystrokes captured by jQuery within the Ember application.

Feb 19, 2016
Loading thumbnail…

Generate a MP4 Video for your Git project commits using Gource!

This example generates a video of a Git project’s commit history as an animated tree visualization. Gource parses the repository’s log data and renders contributors, files, and directories as moving nodes and edges against a black background. The output, at 1920×1080 resolution, is piped as a PPM stream from Gource into ffmpeg, which encodes it as an H.264 MP4 file using the libx264 codec with ultrafast preset and a constant rate factor of 1. A secondary ffmpeg pass compresses the result into a smaller `reposm.mp4` file.

Dec 8, 2015
Loading thumbnail…

Adds "Move to Top" and "Move to Bottom" items to the inspector context menu of components.

This example adds “Move to Top” and “Move to Bottom” commands to Unity’s inspector context menu for any Component. It shows how editor scripting can reorder components on a GameObject using SerializedObject and SerializedProperty, specifically via the `m_Component` array and the `MoveArrayElement` method. The code locates the target component by iterating over array elements and comparing object references, then applies the modification with `ApplyModifiedProperties`. It relies on UnityEditor’s MenuItem attribute to attach the commands to the Component context menu.

Aug 4, 2015
Loading thumbnail…

flux ubuntu 15.04

This visualization shows the setup process for f.lux-indicator-applet, a graphical indicator for managing screen color temperature on Ubuntu 15.04. The shell script executes a sequence of commands, beginning with `apt-get` to install Python dependencies (python-gconf, python-glade2, python-appindicator), then clones the project from GitHub, makes the setup script executable, and runs it via `sudo`. No charting library or rendering API is present; the display consists solely of the terminal command script itself, using standard shell syntax and Git operations.

Jul 7, 2015
Loading thumbnail…

Inject a library from a cdn in any website through the console

This example demonstrates a browser console script that injects the jQuery library into any website from a content delivery network. The code creates a new `<script>` element, sets its type to `text/javascript`, assigns the jQuery CDN URL as the source, and appends it to the document’s `<head>`. The snippet relies on the DOM API `document.createElement` and `appendChild` to perform the injection. It shows a manual, console-based method for loading external JavaScript dependencies without a package manager or build step.

Jun 30, 2015
Loading thumbnail…

Unity logging wrapper, for better performance and usage.

This example shows a static, wrapper class in Unity that centralizes and extends the engine’s native logging capabilities. The code defines a `Log` API with methods for error, warning, message, and verbose severity levels, each offering both standard and format-string variants, with optional Unity `Object` context parameters for console traceability. It internally delegates to Unity’s `Debug.LogError`, `Debug.LogWarning`, and `Debug.Log` calls. The verbose tier uses `System.Diagnostics.Conditional` annotations to exclude its calls from release builds, and prefixes output with a grey `[VERBOSE]` tag.

Nov 27, 2014
Loading thumbnail…

Camera movement script in Unity3D. Supports rotating, panning, and zooming. Attach to the main camera. Tutorial explaining code: http://jibransyed.wordpress.com/2013/02/22/rotating-panning-and-zooming-a-camera-in-unity/

This example shows a Unity3D camera control script that lets users rotate, pan, and zoom the main camera with mouse input. It uses the Unity `Transform` API and `Input` class to handle mouse-button events, applying `RotateAround` for rotation, `Translate` with `Space.Self` for panning, and `Translate` with `Space.World` for zooming. The script calculates movement from screen-to-viewport coordinates to map mouse displacement, with configurable speed variables for each action.

Oct 18, 2013
Loading thumbnail…

Read this in X minutes Liquid Filter Plugin (for Jekyll)

A Jekyll plugin calculates an estimated reading time for any page’s content, displaying it as a label such as "about 4 minutes." The `ReadingTimeFilter` Ruby module defines a `reading_time` filter that splits the input text into words, divides by a fixed 180 words-per-minute rate, and floors the result to produce whole minutes. It handles pluralization and returns "less than 1 minute" for short texts. The filter is registered with `Liquid::Template.register_filter`, and the code includes comments showing its usage within template markup.

Jun 17, 2013
Loading thumbnail…

Unity Better Debug script

This example presents a custom Unity debugging utility class, `D`, that wraps standard `UnityEngine.Debug` methods—`log`, `warn`, `error`, and `assert`—with conditional compilation attributes. It shows how to control which debug levels compile into a build using preprocessor symbols like `DEBUG_LEVEL_LOG`, `DEBUG_LEVEL_WARN`, and `DEBUG_LEVEL_ERROR`. The code uses `[System.Diagnostics.Conditional]` attributes to strip calls at compile time for the chosen platform, and `Debug.Log`, `Debug.LogWarning`, `Debug.LogError`, and `Debug.Break` for runtime output and pause behavior. The methods accept format strings and parameter arrays, mirroring `string.Format` patterns.

Nov 8, 2012
Loading thumbnail…

Gist a03e53f32d7cda243f0f

This example demonstrates how to configure GNOME Shell so that both the primary and secondary monitors switch workspaces together, rather than keeping the second monitor fixed to a single workspace. The code shows a shell script that instructs users to open `gconf-editor` and navigate to `/desktop/gnome/shell/windows/workspaces_only_on_primary`, setting the value to `false` to disable the default behavior. The visualization relies on the GConf configuration system to alter the desktop environment’s workspace behavior, with the script providing the exact key to modify. No external data or rendering library is used; the approach is purely a system configuration change.

Mar 13, 2012
Loading thumbnail…

The best and greatest tmux.conf ever

This example visualizes a configuration file for tmux, the terminal multiplexer, as a demonstration of practical customization. The code shows a text-based interface configuration using tmux’s built-in command syntax, including key bindings, pane and window navigation, and status bar theming. It employs tmux’s `bind-key`, `set-option`, and `set-window-option` commands to define behavior, such as Vim-style pane selection and automatic window titles. The status bar uses tmux’s formatting syntax with color attributes and system commands, like `whoami` and `cut` on `/proc/loadavg`, to display session information. The rendering is purely textual, reflecting a terminal environment rather than graphical output.

Sep 20, 2011