Skip to main content
Start free
A

andybak

@andybak·191 public vizzes

Loading thumbnail…

Gist ac3b3d8bc1faa1422b4260218a23d444

A userscript injects a persistent "EDIT" link into Gitbook documentation pages. The script uses the Tampermonkey API via a `@match` directive and runs on `docs.openbrush.app`. It appends a fixed-position anchor element to the document body with `appendChild`, styling it through inline CSS properties. The link’s `href` updates on mouseover by replacing the current URL’s path with an equivalent Gitbook editor address, using `document.location.href` and string concatenation. The code relies on `setTimeout` to delay injection by one second, ensuring the page has loaded before modification.

Apr 23, 2026
Loading thumbnail…

Gist 0ea3280775a189e0e80fa93b2445e92e

This visualization embeds an interactive 3D astronaut model from the Icosa gallery. The page uses an iframe with the `icosa.gallery` embed URL, enabling fullscreen, autoplay, and WebXR spatial tracking for immersive viewing. The model is rendered in real time, likely using Three.js behind the scenes, and supports touch or mouse interaction through the iframe’s sandboxed environment. No additional data processing or charting libraries appear in the code; the focus is solely on presenting the pre-built 3D asset.

Oct 21, 2025
Loading thumbnail…

Gist 60c6c823175fff2631bbf7587d72ca23

This Django admin tool audits and cleans up orphaned 3D assets by finding assets with no viewable formats, showing a breakdown of them by import source, and then deleting them (optionally filtered by source, with dry-run and confirmation safeguards). A companion script converts Sketchfab viewer camera snapshots into presentation data for the glTF scene, computing perspective camera rotations and backgrounds. The visualization shows a breakdown of orphaned assets by import source, displayed as a simple text-based bar chart in the terminal. The chart is generated by counting assets per source (e.g., sketchfab) and printing each source name with its count, sorted alphabetically. This is a lightweight, command-line data summary rather than a graphical visualization, designed to help administrators understand the distribution of orphaned assets before cleanup.

Oct 14, 2025
Loading thumbnail…

Gist 7c15fbfb157f2db0cfe3dfc4f5583a06

This visualization displays a bipartite matching between two sets of YouTube video IDs, likely representing recommended or related videos. Built with Vue, the page pairs each left-side video ID with a right-side counterpart via curved links. The matching algorithm produces a dense, organized network of connections that reveals the one-to-one relationships between the two groups. The layout positions the two sets as vertical columns with arcs connecting them, making the pairings immediately visible. The visualization functions as a practical tool for exploring how videos map to one another, with the gist providing a clean, functional interface for this data.

Apr 1, 2025
Loading thumbnail…

Gist 890a9efc19689b5b755e9d5c26315c73

This example shows a Godot editor plugin that automatically swaps materials on imported GLTF and GLB scenes. It uses the `EditorScenePostImport` API to intercept post-import processing, checks import metadata to avoid re-processing, and recursively traverses the scene graph to replace materials on `MeshInstance3D` nodes. The code defines replacement `StandardMaterial3D` instances with albedo colors, textures, and metallic properties, loading texture files from a local addon directory. The plugin registers itself through `EditorPlugin` and skips non-GLTF files.

Mar 11, 2025
Loading thumbnail…

Gist b96af6717949aa0f18b8b29b20b51448

This visualization maps the Poly API’s asset and user endpoints as an interactive force-directed network. Nodes represent API methods, path parameters, query parameters, and response schemas, with edges linking related elements. It uses d3.forceSimulation for layout and SVG rendering to display the API structure. The data comes from the API’s documentation file, with node colors distinguishing endpoints from schemas.

Feb 5, 2025
Loading thumbnail…

Gist 786ba24d8dc3ab6d65192a9b8b74b2a5

This visualization uses the Google Poly API to display a catalog of 3D assets, letting viewers browse objects by category and format. The code fetches asset metadata from the Poly discovery document and renders it with a custom interface built on JavaScript. A force-directed layout via `d3.forceSimulation` positions thumbnail nodes, while hover interactions reveal asset details. The visualization relies on the Poly REST endpoints for listing and retrieving assets, showing how API data can be transformed into an interactive spatial arrangement.

Feb 5, 2025
Loading thumbnail…

Gist 6ccd9c4ef2c862306f62bc847ac036d3

This WebGL visualization displays 3D models sourced from Google Poly, processed from original scene data into canonical JSON format. Using Python scripts, the code extracts embedded asset information from HTML pages and decomposes transformation matrices into rotation, translation, and scale components. The visualization renders the reconstructed 3D scenes through WebGL, leveraging the parsed model data and file type metadata from the Poly asset structure.

Dec 21, 2024
Loading thumbnail…

Generic server listener for Blender

This example demonstrates a Blender add-on that runs a local HTTP server to receive 3D model import requests from an external source. It shows how Blender can act as a live listener, accepting OBJ or GLB file URLs via POST requests and queuing them for import. The code uses Python’s `http.server` and `socketserver` for the network layer, with a background thread processing a `queue.Queue` of incoming model URLs, while also tracking recent imports to prevent duplicates and exposing `/ping` and `/status` endpoints for monitoring.

Dec 16, 2024
Loading thumbnail…

Gist 3123920bae0bae527715dcb6f6752384

This example shows a Unity Editor tool that separates a Tilt Brush sketch into individual strokes or color groups. It presents a dialog offering “Group By Color” or “All Strokes” modes, then duplicates selected GameObjects and rebuilds their meshes accordingly. The code uses Unity’s EditorUtility.DisplayDialogComplex and DisplayCancelableProgressBar for interactive feedback, and processes mesh triangles via MeshFilter, mesh.colors, and mesh.triangles. In color mode, it averages triangle colors to cluster geometry; in stroke mode, it isolates each vertex’s stroke index. The tool relies on Undo.RegisterCreatedObjectUndo to support editor undo.

Dec 13, 2024
Loading thumbnail…

Gist 97014fa0c26abd2904c7ba9d22ab9e57

This visualization maps the structure of Google Poly’s 3D asset files by parsing embedded JSON from saved HTML pages. It converts transformation matrices into quaternions, translations, and scales, then categorizes each file’s role (e.g., original glTF, USDZ, OBJ) using role IDs. The code processes thousands of assets, extracting metadata to reveal how different file formats and roles are distributed across the collection. It relies on Python’s `json`, `re`, `math`, and `os` modules for data extraction and matrix decomposition, with the final output intended for further analysis or charting.

Oct 28, 2024
Loading thumbnail…

Gist 234bdecaa64b3487505f6886f9daa54c

This example presents a 3D virtual Crater scene built with the Mozilla Hubs framework and Spoke editor, exporting a GLTF-style JSON scene graph. It shows a spatial environment with a ground plane, a nav mesh, a floor plan, and a spawn point, populated with interactive media frames and an audio zone. The scene uses Three.js-compatible node and mesh definitions, along with Hubs components like box-collider, waypoint, and trigger volume to define physics and navigation. A networked media frame is positioned to display 2D content, while the scene background is set to a gray color.

Sep 19, 2024
Loading thumbnail…

Gist 4e55f8e8b799944cb6b33e98fd168250

This visualization shows a networked 3D scene assembled from GLTF assets, with a grid of nodes representing interactive media frames, text labels, and environmental elements like water, sky, and lighting. The code defines a complete virtual space using Three.js-style scene-graph components, including spawn points, waypoints, audio zones, particle emitters, and colliders. A central box-collider acts as a ground plane, while the scene includes a nav-mesh for navigation and a hidden trigger volume. The setup demonstrates how MIXED REALITY components—such as networked objects, media frames, and physics properties—combine to create a shareable, interactive environment with URLs for external image, video, and audio assets.

Sep 18, 2024
Loading thumbnail…

Gist 07d372884fec99f6d8785ba677d2fa2d

This example shows a Unity scene converting SVG path data into spline-based curves for use in a SplineContainer. It parses an SVG file using `RuntimeSVGImporter` and `SVGParser.SceneInfo`, then iterates through the scene’s shape contours, converting each Bézier segment into a `BezierKnot` within a new `Spline`. The code applies translation, rotation, and scaling transforms to the points before adding them, and it supports extracting a single node by ID or child index. The result is a set of splines representing the original vector graphics, ready for manipulation in Unity’s spline system.

Jul 28, 2024
Loading thumbnail…

Gist 3a03bac4ed27ab3c1ca3d87cc21fcd9d

This userscript adds a fixed "EDIT" link to the top-right corner of GitBook documentation pages for two specific sites: OpenBlocks and OpenBrush. The script determines which documentation site is currently open by checking the URL, then constructs the corresponding GitBook editing URL by replacing the documentation domain prefix with the appropriate GitBook organization and space path. It uses the Tampermonkey API and plain DOM manipulation to create the anchor element, set its styles, and update the link dynamically on mouse movement.

Jul 16, 2024
Loading thumbnail…

Gist 788c07fefb1d6fb9dfe6d546010188e1

The visualization displays a pie chart of file type counts across a directory tree, highlighting dominant extensions while omitting labels and percentages for slices under 5%. It also computes and prints statistics for GLTF generators, JSON format types, and directory extension combinations. The chart is rendered with Matplotlib’s `plt.pie`, using `autopct_func` to conditionally show percentages and larger font sizes for readability. Data is collected by scanning subdirectories with `os.walk` and JSON parsing via `json.load`.

Jul 13, 2024
Loading thumbnail…

Gist a54028cfd44222a5c43a6bab02aad770

This example showcases a collection of procedurally generated grid-based polyhedral meshes, including hex, square, triangle, rhombille, Cairo, and Penrose tilings, each rendered as a 3D Unity mesh. It demonstrates how the Sylves library constructs and bounds different grid types, converting them into PolyMesh data via `grid.BoundBy(bound).ToMeshData()` and processing the resulting indices based on topology (triangles, quads, or NGons). The code uses Unity’s `MeshFilter` and `MeshRenderer` components, along with the Polyhydra Core library, to visualize each grid’s cell layout at a user-defined size.

Apr 6, 2024
Loading thumbnail…

Gist f29593152ca24bfc3585d9845a502c02

This visualization demonstrates a procedurally generated 3D model viewer that fetches a random Kenney model from the poly.pizza API. When the brush trigger is released, it requests a new model, imports it, and displays it in the scene. The code uses Lua with the lume library for random selection, WebRequest calls to the poly.pizza REST API, and Three.js’s Model:Import function to load the downloaded geometry. The data source is the poly.pizza user "Kenney" model list, with each model’s download URL retrieved from the API response.

Oct 6, 2023
Loading thumbnail…

Gist 38e049a8e58056d8542d9ee67c7957e0

This example shows a simple 3D pyramid whose apex moves upward or downward when the user presses the arrow keys. It demonstrates how to create and update a mesh at runtime using Unity’s Mesh API, with vertex data stored in a `NativeArray<float3>` for efficient modification. The code sets up a triangle-based submesh, defines vertex and index buffers via `SetVertexBufferParams` and `SetIndexBufferParams`, and redraws the mesh each frame with `Graphics.DrawMesh`. The pyramid is rendered using a provided material, and only the top vertex’s position is altered in response to input.

Sep 24, 2023
Loading thumbnail…

Gist b589797791ad5ef2b76af89dc118981e

This visualization reimagines Jorge Luis Borges’s “Celestial Emporium of Benevolent Knowledge” taxonomy as an interactive force-directed graph. Each of the fourteen categories and their three example creatures appear as nodes, with links connecting each creature to its category. The code uses `d3.forceSimulation` with `forceLink` and `forceCollide` to position nodes, while drag and zoom interactions rely on `d3.drag` and `d3.zoom`. Categories are distinguished by color, and hovering highlights connected nodes. The data is drawn directly from the embedded `borges.json` file, with labels rendered via SVG text elements.

Mar 28, 2023
Loading thumbnail…

Gist 55d11f1b29079ced31e8868aac3bd9e9

This example shows a Blender add-on that receives 3D drawing strokes from Open Brush via HTTP and renders them as grease pencil strokes in the 3D viewport. A Python HTTP server with a custom `RequestHandler` listens for POST requests containing multipart form data, parses stroke point coordinates from JSON, and converts them into Blender Grease Pencil layers and frames using the `bpy.types.GreasePencil` and `GPencilLayer` APIs. The add-on provides start and stop operators to control the server connection on port 8080.

Mar 24, 2023
Loading thumbnail…

Gist 1b1c584b62bbf80f4e95935d9654a5c9

This example demonstrates a virtual-reality drawing tool where users can create and manipulate 3D paths, strokes, and shapes in a spatial environment. The code uses the Tilt Brush API, including functions like `draw.path`, `strokes.select`, and `headset.pastPosition`, to render SVG-derived geometry and apply transformations such as translation, rotation, and scaling. It also supports symmetry modes, camera-path recording, and layer management, with turtle-style drawing commands and Unity Mathf utilities for calculations. The visualization shows how procedural and imported paths can be interactively positioned and edited within a VR scene.

Feb 23, 2023
Loading thumbnail…

Gist c700120232ca68a90adc791f75c8a16c

This example demonstrates a Python client for controlling a 3D drawing environment through a local HTTP API. It shows how to remotely manipulate a brush, spectator camera, and user position using simple method calls that construct URLs with query parameters. The code uses `urllib.request.urlopen` to send commands to a server at `localhost:40074`, enabling actions like drawing strokes, moving the brush, turning the camera, and toggling spectator mode. It also provides shortcuts for showing folders, exporting sketches, and listening for stroke data, making it a toolkit for interactive visualization scripting.

Dec 20, 2022
Loading thumbnail…

Gist 3190091e6dc9276868c5ad91d323ef6b

This example deletes the `Library` folder from every Unity project directory under a specific local backup path. It first constructs a list of `Library` subdirectories using `os.listdir` and `os.path.join`, then removes each one with `shutil.rmtree`, filtering out non-directories with `os.path.isdir`. The code relies solely on Python’s standard `os` and `shutil` modules, showing a file-system cleanup routine rather than a visualization. The data source is the local directory structure of the user’s Unity projects.

Aug 30, 2022
Loading thumbnail…

Gist 163847197f2c33368934a7c89ba711bc

This example visualizes a particle system and its interactions, built with the Unity game engine. It uses Unity's built-in modules for rendering, physics, and user interface elements, including the TextMeshPro and UI systems. The visualization is driven by Unity's component-based architecture, with a manifest that declares the package dependencies. The work does not use typical JavaScript data-visualization libraries like D3 or Three.js; instead, it leverages Unity's own animation, audio, and particle system modules to create the interactive scene.

Apr 20, 2022
Loading thumbnail…

Gist 6e56678993df5a603e27787a7af84f9c

This visualization shows a virtual reality scene of an open brush painting environment, with a headset and controllers rendered in 3D space. The configuration file sets up video capture parameters for exporting the scene, including resolution, frame rate, and camera smoothing. It uses Three.js for 3D rendering and specifies post-processing effects, FBX export options, and audio settings. The data originates from a Full of Eyes YouTube channel and is configured for both online and offline video output, with camera path saving enabled.

Mar 25, 2022
Loading thumbnail…

Gist 84610558b586c9100d7b8362842eda4d

This example shows a Unity Editor tool that lists every brush texture used by Tilt Brush, displaying the brush name, texture property, whether the texture is readable, and its asset path in the console. It iterates through default and experimental brushes loaded via `Resources.LoadAll`, skips deprecated brushes based on `m_Supersedes` references, and uses `AssetDatabase.GetAssetPath` to resolve texture paths. The code relies on Unity’s `BrushDescriptor`, `Material.GetTexturePropertyNames`, and `StringBuilder` to compile and log the report.

Dec 23, 2021
Loading thumbnail…

Gist 2bf4f8f77b581264da82c111addb1dd0

This example provides a web-based control panel for managing a 3D virtual reality drawing environment. It allows users to configure brush types, sizes, and colors, as well as set the spectator camera’s position, target, and movement modes like stationary, follow, circular, or wobble. The interface also toggles visibility of canvas layers, UI elements, and user tools, and triggers actions such as saving, exporting, or clearing the scene. The code uses plain HTML form controls and JavaScript event handlers, with template placeholders for brush and environment data, but does not rely on external visualization libraries.

Nov 11, 2021
Loading thumbnail…

Gist 75d667d57672bebeec871c6adb853983

This example demonstrates how a 3D model is imported and placed into a scene at a specified position and rotation. The code uses the SketchMemoryScript and WidgetManager APIs to create a new model widget, load a file from the media library, and associate it with a TrTransform containing the given translation and rotation. It then shows the widget, disables dormant widget mode, and clears any current selection. The rendering approach relies on the Model class with its LoadModel method, while the CreateWidgetCommand handles undoable scene changes.

Jul 16, 2021
Loading thumbnail…

Gist ce2d0ae16f469275661564df223c4a0c

This example displays a long, alphabetically sorted list of brush names in a scrolling text interface, with a large color swatch and hexadecimal color readout updating in real time. It uses a custom rendering loop with Canvas API drawing operations to generate a procedural color gradient based on mouse position. The code references `requestAnimationFrame` and Canvas `fillRect` to continuously repaint the background, while the list itself is rendered as plain HTML text. No external visualization libraries are used; the interaction is limited to mouse movement affecting the displayed color.

May 16, 2021
Loading thumbnail…

Gist f8797295d3575bca4ec2c444e035e8bb

The visualization is a line chart showing a sequence of data points, rendered as a single continuous path. The line is drawn using SVG path data with a red stroke, positioned against a plain background with minimal styling. It appears to be a simple time-series or sequence plot, where the path connects coordinates across a fixed horizontal axis, with the line rising and falling as it progresses from left to right. The chart uses no axes, gridlines, or labels, suggesting a minimalist or abstract presentation of the data.

May 14, 2021
Loading thumbnail…

Gist dfcea3b47dd624057d397482a0ea6a9e

This interactive example demonstrates a parametric drawing tool that generates a repeating geometric pattern from adjustable turn angle, line length, and repeat count. The user modifies values in the input fields and clicks Run, which sends commands to a drawing server via the `XMLHttpRequest` API, using `GET` requests to an `/api/v1` endpoint. Each command sets brush properties such as color, size, type (comet), turn, and draw/move distances, while the color shift per repetition creates a gradual hue gradient. The pattern is built by repeatedly issuing turn, draw, and move commands, producing a starburst-like sequence.

May 14, 2021
Loading thumbnail…

Gist bbd575c20a64fd4402a75d507da5c31f

This example demonstrates a 3D drawing and camera-control system built around a command-driven API. It shows how a user can manipulate a virtual brush, reposition the camera, and toggle features like symmetry, straightedge, and autoorient through a set of named commands. The visualization uses Three.js-like vector operations for translations and rotations, while commands such as `brush.draw` and `camera.teleport` are executed sequentially. It also includes save/load functionality with user and curated indices, plus export options for the scene. The code defines a protocol for capturing drawing actions, rendering them in 3D space, and managing user interactions.

May 14, 2021
Loading thumbnail…

Gist ff5ecb0cfd5b540608efaf7cdaad30d3

This visualization maps Unity shader properties onto a force-directed network, showing how different shader materials relate through shared parameters. Using d3.forceSimulation, nodes represent individual shader names like Bubbles, Fire, and Ink, with edges likely connecting shaders that share property types. Each node’s properties—such as float, color, texture, or vector—are parsed from the gist text, revealing patterns in shader design. The layout groups similar shaders spatially, making it easy to spot clusters of materials with common attributes like emission or specular settings.

Apr 21, 2021
Loading thumbnail…

Gist 274a5a6067cf7b0ba3ea0762382b0112

This visualization demonstrates a virtual brush stroke system inspired by the Tilt Brush "Wire" material, using JSON-defined properties for rendering and physics. The experimental configuration adjusts float parameters like displacement, emission scroll, and squeeze amount, while the master brush file specifies material shaders, particle rates, and tube geometry. The code relies on structured data schemas to validate and interpret brush settings, with no external visualization libraries visible; instead, it appears to be a custom renderer that parses the JSON to control stroke appearance and animation.

Apr 12, 2021
Loading thumbnail…

Gist 51c01feaecb233e0500851a1bb5ee30b

This visualization displays the 93 isohedral tilings classified by their wallpaper group and tile shape. Each entry is represented as a small, clickable tile diagram, arranged in a grid. The code uses SVG paths to draw the geometric patterns and labels each with its IH number and group. The data comes from the provided TSV file, which is loaded and parsed to generate the layout.

Apr 8, 2021
Loading thumbnail…

A Material Property Drawer for the [Gradient] attribute which lets you edit gradients and adds them to the shader as textures. More information here: https://twitter.com/totallyRonja/status/1368704187580682240

This drawer adds a gradient editor to Unity’s Material Inspector for shader properties marked with the `[Gradient]` attribute. It converts the edited gradient into a 1D texture, bakes it using `Texture2D.SetPixel` and `Apply`, and assigns it to the material via `Material.SetTexture`. The tool stores and reloads gradients by encoding them as JSON in the texture’s asset name, using `JsonUtility` and `AssetDatabase` for persistence, with a fallback blue-to-red default.

Mar 8, 2021
Loading thumbnail…

Gist a3b086e4ec021188c08a4afa990e988e

This example shows a Unity shader that applies triplanar texture mapping to surfaces, blending three planar projections based on each fragment’s local normal direction. The shader, written in HLSL with the Standard Surface shader model, samples a main texture, normal map, and occlusion map across the X, Y, and Z axes, then weights the results by the normalized absolute normal components. It supports transparency, metallic, glossiness, and occlusion parameters, and relies on Unity’s `surf` and `vert` functions. The code is adapted from keijiro’s StandardTriplanar shader and runs in the Unity engine.

Mar 4, 2021
Loading thumbnail…

Gist 1aef7ee80b94a5ba6afb087f89ef50aa

This example shows a Unity script that repositions an object’s parent so a tracked target aligns with a designated “feet” GameObject. It computes the offset vector between the feet and target, then subtracts that vector from the parent’s position to shift the entire hierarchy. The script runs automatically when the component is enabled, calling `MoveToTarget()` in `OnEnable`, and exposes the same method publicly for manual invocation. It uses Unity’s `Transform` API, including `position` and `transform.parent`, to perform the direct positional correction without physics or animation.

Feb 25, 2021
Loading thumbnail…

Gist 1f68df120144a1363690cc4cfe88d426

This example uses Unity Editor scripting to extract and log configuration data from Tilt Brush’s PanelManager and BasePanel classes. Two menu commands, “Tools/Panel Lister” and “Tools/Popup Lister,” access private fields via reflection to enumerate panel and popup mappings. The first command outputs a tab-separated list of panel attributes like m_Advanced, m_ModeVr, and m_PanelPrefab, while the second lists popup commands and their associated prefabs. The code relies on Unity’s StringBuilder, Debug.Log, and reflection APIs (GetField, GetValue) to inspect runtime objects.

Feb 16, 2021
Loading thumbnail…

Gist e783e9e7df0dc768c4e7a8bc773de936

This example demonstrates a Tilt Brush tool that generates polyhedral brush strokes in virtual reality. It shows how a Conway polyhedron’s faces are converted into stroke control points and drawn as colored line segments. The code uses PolyhydraBrushHelper to generate the geometry, then iterates over each face’s halfedges to build control points with position, orientation, and pressure data. Strokes are created via the Stroke class and memorized in SketchMemoryScript, with face colors applied from polyHelper.GetFaceColor().

Feb 11, 2021
Loading thumbnail…

Gist a073910bd2f3b7e0956d989ccc0dd1d5

This example generates a tab-separated inventory of Tilt Brush brush descriptors by loading all brush resources via `Resources.LoadAll` from both the default and experimental “X/Brushes” folders. It filters out deprecated brushes (those with a `m_SupersededBy` reference) and extracts each brush’s description, audio-reactive flag, prefab name, material name, and MonoBehaviour script components (using Unity’s `GetComponents`), then writes the rows to a `StringBuilder` and logs them with `Debug.Log`. The code relies on UnityEditor’s `MenuItem` attribute to expose the tool in the editor menu, and it handles missing experimental prefabs by catching `UnassignedReferenceException`.

Feb 11, 2021
Loading thumbnail…

Gist 4bad9d7e5912f181148d97187d299368

This example demonstrates an attempt to create a stroke geometry in a virtual reality sketching tool using the Tilt Brush-style API. It shows how a new `Stroke` object is instantiated with control points, brush settings, and a seed, then passed to `stroke.Recreate()` for rendering on the active canvas. The code uses `InputManager`, `PointerManager`, and `App.Scene.ActiveCanvas` from the Tilt Brush framework, along with Unity’s `Transform` and `Vector3` for positioning. However, the stroke remains invisible in the scene, as noted in the file comment, indicating a likely issue with the recreation or rendering pipeline. The data source is procedural control points generated from the tool’s attach point.

Feb 10, 2021
Loading thumbnail…

Gist dc420281117ae336a18c1bf3069fc932

This example demonstrates how to create a parametric stroke in Tilt Brush using a tool script. It shows the instantiation of a `CircleCreator` attached to the active canvas, followed by the creation of a new line through the `PointerScript` and the setting of a keeper control point. The code relies on Tilt Brush’s `App.Scene.ActiveCanvas`, `ParametricStrokeCreator`, and `PointerManager.m_Instance` APIs to drive the pointer interaction, defining the stroke’s geometry and capturing it as a persistent element.

Feb 9, 2021
Loading thumbnail…

Gist c83bdc4de5e6486850b79ddfc73b899f

This example shows a networked virtual-reality interaction system where objects are grabbable by remote users, with ownership transferred to the grabbing hand. It builds on Unity’s OVRGrabbable and Photon PUN2 APIs, using PhotonView to manage ownership and RPCs like SetKinematicTrue and SetKinematicFalse to synchronize physics states across all clients. The script also triggers custom UnityEvents on grab and release, and optionally hides the hand’s SkinnedMeshRenderer during a grab. The behavior is driven by the hand’s PhotonView.IsMine check, ensuring only the local player’s actions affect the object.

Nov 6, 2020
Loading thumbnail…

Gist 63540e65c30a453a7e2e9b0345aa42ce

This example renders a 3D cityscape from geospatial building footprints, showing extruded building volumes colored in a uniform teal tone. It queries buildings within a given distance of a latitude/longitude point using Django’s GeoQuerySet (`outline__dwithin`) and converts each polygon outline with Shapely, then extrudes it with Trimesh’s `creation.extrude_polygon`. The scene is centered via a translation matrix, scaled, and exported as a GLB file using Trimesh’s `exchange.gltf.export_glb`. The visualization highlights building heights relative to their footprint areas.

Oct 16, 2020
Loading thumbnail…

Gist 69cfbb7f237e72e9bcbd21744278a5f8

Procedurally generated from a base grid, this scene depicts a small town of varied houses topped with domes, built using the Antimony graph modeling library. The code constructs a jittered grid, extrudes random-height house blocks, and splits them into walls and domes, which are then shaped with lofting, shelling, and dome operations. A beveled and medial ground plane is added, and the final model appends all parts together. The example demonstrates Antimony’s grid, face-selection, and transformation APIs for generative architectural form.

Sep 17, 2020
Loading thumbnail…

Gist e052414ca97f9d5f835b6090330c968d

A procedural town is generated from a jittered grid, producing extruded houses with window openings, domed roofs, ground patterns, and building edging. The example uses the `Grids.Grids` API to create the base grid, then applies `Loft`, `FaceSlide`, `FaceRemove`, `Shell`, `Dual`, `Bevel`, `Medial`, and `FaceScale` operations from the `ConwayPoly` geometry library. Random building heights and dome profiles are driven by `Random.Range` and an easing function, with all parts assembled into a single `ConwayPoly` object for display.

Sep 17, 2020
Loading thumbnail…

Gist f05cafe1da03a8d334462f2fa63825f4

This shader effect creates a flowing, directional distortion of an input texture by sampling it multiple times around each pixel. It computes eight rotated sample offsets, gathers luminance from both inner and outer rings, and accumulates a motion vector that steers the final texture lookup. The result is a smeared, energy-driven displacement that makes the image appear to shift and swirl based on its own brightness. The implementation uses GLSL in Shadertoy’s `mainImage` function, relying on `texture` calls to `iChannel0` and arithmetic on normalized pixel coordinates (`fragCoord` and `iResolution.xy`).

Aug 31, 2020
Loading thumbnail…

Gist bdb66899015ed6b7ab9d04034580909a

This example procedurally generates 3D spaceship models using the Conway polyhedron and Johnson solid libraries in Unity. The code builds a base prism, then applies random operations—lofting, lacing, truncating, and adding wings or engines—across multiple sections to create varied ship silhouettes. It uses Unity’s `MeshFilter`, `MeshRenderer`, and `Random` APIs to construct and display the final mesh, with adjustable parameters like nose length, sharpness, and segment complexity. The generator runs automatically on validation and exposes seed-based randomness for reproducible variations.

Aug 21, 2020
Loading thumbnail…

Gist d645d3d5abe4993556a6a2132722919a

This example demonstrates a mesh-subdivision algorithm that transforms a Conway polyhedron by offsetting its vertices and adding new faces at edge midpoints. It shows how the original geometry is refined into a smoother, more complex structure while preserving the polyhedron’s topological connectivity. The code uses custom `ConwayPoly`, `Face`, `Halfedge`, and `Vector3` classes, along with LINQ operations like `Select` and `Find`, to manipulate vertex positions and face indices. The rendering approach relies on the polyhedron’s internal data structures, with the offset parameter controlling the inflation of each vertex along its normal.

Aug 16, 2020
Loading thumbnail…

Gist 92b2b6610d2371b2da7c34152657f751

This visualization demonstrates Möbius transformations applied to a 3D object in real time. A shader written in Unity’s ShaderLab and CG/HLSL takes each vertex, performs a reverse stereographic projection onto a 3-sphere, rotates the hypersphere in 4D space, then projects back to flat 3D. The user controls the rotation amount via the `_Amount` slider. The surface shader uses the Standard lighting model and applies vertex colors, with adjustable saturation, smoothness, and metallic properties through exposed parameters.

Aug 12, 2020
Loading thumbnail…

Gist ae31ce5b693d662b3add4af2919cea65

This example shows a Unity application that captures frames from a camera, sends them to a remote machine-learning API, and displays the stylized result in a UI Image component. It uses MiniJSON to serialize the image as base64-encoded PNG data into a JSON payload for a POST request to a RunwayML-style endpoint. The script repeatedly captures the camera’s RenderTexture at a set interval, uploads it, and updates a Preview sprite with the returned stylized image. It demonstrates real-time image processing through an external model with a simple polling loop to keep the remote service active.

Jun 1, 2020
Loading thumbnail…

Gist 0870263c0c476205b6f7a471f00ee1dc

This example shows a node-based procedural geometry editor that generates primitive meshes and combines them into model groups. It uses the XNode framework to define a graph where a `Primitive` node creates dodecahedra, octahedra, or cubes via the ProceduralToolkit `MeshDraft` API, while a `RandomPrimitive` node supplies the primitive type. The `Primitive` node reads inputs for primitive type, radius, and material, then outputs a `ModelGroup` containing a single `Model` with an assigned material. The graph structure is visible in how node ports connect inputs and outputs, demonstrating how procedural mesh generation can be controlled through a visual scripting system.

May 31, 2020
Loading thumbnail…

Gist 350b55fdacbabd690b789c7958fb7995

This visualization generates downloadable 3D building models from a geospatial database. It queries building footprints within a specified radius of a given latitude and longitude, extrudes each polygon to a height proportional to the building’s height, and centers the resulting scene on the buildings’ centroid. The code uses Django’s GeoDjango for spatial queries, Shapely for polygon manipulation, and trimesh for scene creation and GLB export. The final output is a binary glTF file containing the extruded building geometry.

Apr 10, 2020
Loading thumbnail…

Gist e2cb06e5430585b148afb12bad4bd0f8

A single polyhedron, a Small Cubicuboctahedron, is generated and animated using the Antiprism library’s JSON interface. The model is created from a square-grid cube with a "Cross" operation whose animated amount continuously deforms the shape, while a VertexScale operation sets a fixed scaling factor. The visualization appears as a 3D render, driven by the animation parameters defined in the JSON configuration, though the rendering library itself is not specified in the code.

Jan 8, 2020
Loading thumbnail…

Gist 3743ce0f15cabc0331dce136e0db4168

This example demonstrates a custom outline effect for the Unity Universal Render Pipeline (URP). It consists of a `ScriptableRendererFeature` that injects a depth-normals prepass, which renders the scene’s depth and normal information into a texture. A Shader Graph custom node exposes this `_CameraDepthNormalsTexture` as an input, and an HLSL function compares depth and normal values at neighboring screen-space texels to detect edges. The effect produces a stylized outline by thresholding depth discontinuities and normal differences, with adjustable scale, depth threshold, normal threshold, and texel size.

Nov 17, 2019
Loading thumbnail…

Gist 540bb6cf2f6ceada6387cc673f971498

This example demonstrates how to change an object’s appearance and size at runtime using Unity’s core APIs. It shows a script that accesses a GameObject’s MeshRenderer component to set its material color to red, then modifies the object’s Transform to scale it uniformly to five times its original size. The code relies on Unity’s `GetComponent<MeshRenderer>()` and the `transform.localScale` property, with `Color.red` and `Vector3` supplying the new values. The behavior is triggered directly in the `ChangeStuff()` method, illustrating a simple, immediate state change without animation or external data sources.

Nov 6, 2019
Loading thumbnail…

Gist 8183aad3764bedf7ab23187c08fd1f12

This example renders a 3D mesh of a Brazier-shaped polyhedron, built from a JSON specification and processed through a sequence of geometric operations. The shape starts as a uniform hex grid prism, then applies operations such as `FaceScale`, `Extrude`, and `Kis` to selected upward-facing faces, producing a sculpted, bowl-like form with a faceted interior. The model uses a hex grid type with prism parameters and a "Dirty Metal" appearance preset, suggesting a material-based shading pipeline. The visualization relies on the JSON’s operation list to transform the base geometry, with disabled operations like `Lace` indicating optional refinement steps that remain inactive in the final output.

Oct 24, 2019
Loading thumbnail…

Gist 6dd998ca70e2dc7c80aafed2723a86e7

This example shows a geometric polyhedron, named “Vicious,” rendered with a dark, reflective showroom appearance. The shape begins as a uniform prism-like form and is then modified through a sequence of operations: lacing the faces, scaling and extruding the five-sided faces, and finally applying a Kis operation to those same faces. The visualization uses the Antiprism library’s JSON model format, with parameters such as `PolyType` and `JohnsonPolyType` defining the base solid. The scene is rendered using the Three.js WebGL API, displaying the resulting complex, faceted structure with two-sided surfaces and a hexagonal grid.

Oct 24, 2019
Loading thumbnail…

Gist e8a05cce9a76090a14ba06fd8f53a274

This example demonstrates a minimal Unity camera control utility through a static C# class. It exposes the main camera’s position as a property and provides a method to move it by an offset vector, while also offering a property to read or set the global time scale. The code uses Unity’s `Camera.main`, `Transform.position`, and `Time.timeScale` APIs. It shows how to encapsulate common scene-level operations in a reusable static helper, with no rendering or data visualization logic beyond the camera manipulation itself.

Oct 5, 2019
Loading thumbnail…

Gist 3ea286941ac2e64f1214744f80b99beb

This example demonstrates a VR player controller that manages a timeline-driven animation sequence. It uses Unity’s PlayableDirector to play and pause a timeline, while calibrating the player’s position based on XR headset tracking via UnityEngine.XR. The script checks XRDevice.userPresence to automatically start the timeline when a headset is worn, and rewinds it when removed. It also supports manual control through the Submit input button, toggling between rewind-and-pause and rewind-and-play states.

Oct 2, 2019
Loading thumbnail…

Gist 1973ba4fdee5e215ecb28f0db7f0aadb

This example shows a Unity Editor tool that automatically grants internal access to Shader Graph’s assembly during compilation. It hooks into `CompilationPipeline.assemblyCompilationStarted` to detect when the `Unity.ShaderGraph.Editor` assembly is being compiled, then locates its `AssemblyInfo.cs` file and appends an `InternalsVisibleTo` attribute referencing `BovineLabs.Vision.Editor`. The code uses `File.ReadAllLines`, `File.AppendAllText`, and `File.SetAttributes` to modify the file, while skipping the modification if the attribute already exists.

Aug 29, 2019
Loading thumbnail…

Gist e4337d3399b3937aa809a0179293bd13

This visualization reads a CSV file containing x, y, z position, width, height, depth, and RGB color columns, then plots each row as a colored 3D box in Unity. The data points are normalized to a 0–1 range, scaled by a plotScale factor, and instantiated as prefabs with their original size and color from the file. The code uses Unity’s `GameObject.Instantiate`, `Transform`, and `Renderer.material.color` to place and style each box, with positions and scales derived from the CSV values.

Aug 27, 2019
Loading thumbnail…

Gist 845aa64e9d9aa6080eadd256e863d835

This example visualizes gradient vectors computed from a three-dimensional signed distance field, showing normal directions as RGB colors sampled from a Unity Texture3D. The code uses Unity’s `Texture3D.GetPixel` to read distance values and central differences to approximate the gradient along each axis, storing the result in a new `Texture3D` with `TextureFormat.RGBAFloat`. A `ContextMenu` attribute triggers the bake operation, and `AssetDatabase.CreateAsset` saves the output as a reusable gradient texture asset.

Aug 23, 2019
Loading thumbnail…

Gist 55dffaaebad7fbed3efca0439487341b

This example shows a Unity script that tracks when a virtual object is grabbed and released by a user in an Oculus VR environment. It demonstrates how to trigger custom UnityEvents at the start, end, and during a grab, using the OVRGrabbable component from the Oculus Integration SDK. The script polls the grabbable’s `isGrabbed` state each frame in `Update()` and uses boolean flags to fire the `StartGrab`, `EndGrab`, and `WhileGrabbed` events only once per transition. No data source is involved; the visualization is the real-time interaction state of the object.

Aug 8, 2019
Loading thumbnail…

Gist 48245d988832c60328d729e4c95db8db

This example demonstrates how to request a Mapbox vector tile and initialize it for rendering. The code constructs a `Tile.Parameters` object, sets its `Fs` property to the Mapbox access instance, and converts latitude, longitude, and zoom coordinates into a canonical tile ID. It then creates a `VectorTile` and calls its `Initialize` method with those parameters, passing a callback for tile data. The snippet highlights the step where a specific map style, such as `"mapbox.mapbox-terrain-v2"`, would normally be assigned, but that assignment is omitted here. The rendering approach relies on Mapbox’s tile API and the `VectorTile` class to handle the map data.

Jun 21, 2019
Loading thumbnail…

Gist 1ac3ec54b81ccb1992192549bf25cff4

This example demonstrates a minimal Unity event system triggered by collision detection. A MonoBehaviour script, EventTest, exposes a public Collider field and a UnityEvent. When another collider enters the assigned trigger zone, the OnTriggerEnter callback invokes the UnityEvent, allowing linked responses in the Inspector. The code relies on UnityEngine.Collider and UnityEngine.Events.UnityEvent, showing how Unity’s built-in event and trigger APIs connect gameplay logic without custom messaging.

Jun 12, 2019
Loading thumbnail…

Gist 8dde5bfea433aa824444246c47f0d46f

A custom Unity shader renders double-sided foliage with a spherical normal trick, replacing each vertex’s normal with a direction from the model origin to the vertex. It combines alpha-cutout transparency with Fresnel-based edge fading, using `clip` to discard pixels below a cutoff. The shader applies Lambert diffuse lighting from `_WorldSpaceLightPos0` plus ambient light via `ShadeSH9`, while normals are offset by a vector property. The material is intended for tree models, as noted in the author’s comments, and supports alpha testing in the `TransparentCutout` render queue.

Jun 11, 2019
Loading thumbnail…

Gist 19bd71e9136ab748f798122cfea72440

This example shows how to control a camera’s pitch and yaw using mouse input in the Unity editor, enabling a first-person-style view without a headset. The code reads raw horizontal and vertical mouse axes via `Input.GetAxisRaw("Mouse X")` and `Input.GetAxisRaw("Mouse Y")`, then applies those values to rotation speeds. Pitch is clamped between -90 and 90 degrees to prevent flipping, while yaw rotates freely. The script relies on `Quaternion.Euler` to set the local rotation and uses a `KeyCode` modifier to optionally require a held key. It is disabled outside the editor, as indicated by the `#if !UNITY_EDITOR` directive.

Jun 10, 2019
Loading thumbnail…

Gist 660f765a1eaf8b00dd819920da0c2613

This example converts a selected PNG texture into a 3D mesh using Unity’s Sprite API. It shows how the image’s alpha channel defines a tight sprite outline, which becomes the mesh’s vertex geometry, while the original texture is applied as a material. The code uses `Sprite.Create`, `SpriteMeshType.Tight`, and `Mesh` to build the object, then assigns the Standard shader and recalculates normals, bounds, and tangents. It runs only when a .png asset is selected via the editor menu.

Jun 4, 2019
Loading thumbnail…

Gist a0da4f5f6a6476db55c3fb6a80baadd7

This example shows how to convert a 3D mesh into a point cloud by changing its topology. It displays the original geometry as a set of discrete vertices instead of connected triangles. The code uses Unity’s `MeshFilter` and `Mesh` APIs, setting the mesh’s indices to cover every vertex and applying `MeshTopology.Points` to render each vertex as an individual point. It operates both in edit mode and during play, updating the shared mesh or the active mesh accordingly, making the conversion immediate and visible in the scene.

May 29, 2019
Loading thumbnail…

Gist 1096899d107604614879ac8aa7853933

This example shows how to extract contour line geometry from Mapbox vector tiles and log the coordinates of each point in every polygon. It queries the "contour" layer from the mapbox.terrain-v2 tileset at a specific latitude, longitude, and zoom level using Mapbox Unity. The code instantiates a VectorTile, initializes it with tile parameters, and iterates through the layer’s features, printing geometry type and point coordinates via Debug.Log. It relies on Mapbox.Map.VectorTile and Mapbox.Unity.Utilities.Conversions to convert geographic coordinates to tile IDs.

May 12, 2019
Loading thumbnail…

Gist ae2b5fc0e438fd62bd0ab56bc35904d6

This example demonstrates a Unity-based Bluetooth connection test that scans for bonded devices, attempts to open a serial RFCOMM socket, and sends a short command string. The code uses the `brab.bluetooth` library to access the Android BluetoothAdapter, enumerate bonded devices via `getBondedDevices()`, and create a socket with `createRfcommSocketToServiceRecord()`. It logs each step—device discovery, socket creation, connection, and data transmission—to both the Unity console and a UI Text element, while trimming old log lines after 32 entries. The visible behavior is limited to connection setup and a single write; no incoming data reading is shown.

Apr 26, 2019
Loading thumbnail…

Gist 117c6f1a891bf4503093a2e35d73a593

This example presents a Unity Visual Effect Graph block that blends particle colors using 16 different Photoshop-style blend modes, including Screen, Multiply, Overlay, and Difference. It shows how the block reads and writes the particle color attribute through the VFXAttributeInfo API, while exposing a blend color input and a mode selector via VFXSetting. The code implements each mode as a custom HLSL snippet, with conditional expressions for modes like SoftLight and HardLight, applied directly to the color value in the particle update or output context.

Mar 6, 2019
Loading thumbnail…

Gist 409cdc37f3f7116d93eac738995d14ab

This example shows a Unity-based 3D modeling interface where users subdivide a cube or quad primitive into finer meshes. A grid of buttons lets the user choose different subdivision resolutions (from 2x2 up to 6x5), with the current state highlighted. Selecting a subdivision switches the mesh and opens a vertex-mover dialog for fine-grained editing, while an intermediate confirmation step is shown if vertex changes already exist. The included JSON conversion functions demonstrate how changed vertex positions and smoothing angles are serialized and restored, including reference-based deduplication of shared vertex patterns.

Oct 16, 2018
Loading thumbnail…

Gist a33a5c0eb38ae642af46a478b3951163

A Unity shader demonstrates a mesh-spherization effect by morphing a flat textured surface into a sphere. The vertex shader normalizes each vertex position, scales it by a configurable radius, and blends between the original and spherical coordinates using an amount parameter. The fragment shader samples the main texture and halves its color output. The shader uses Unity's `UnityObjectToClipPos` for projection and applies fog through standard CG macros. The material exposes radius and amount properties for interactive control.

Sep 30, 2018
Loading thumbnail…

Hex dots shader for unity. From: https://www.reddit.com/r/Unity3D/comments/9h07rh/i_made_a_shader_that_draws_a_bunch_of_dots_in_a/

A Unity shader renders a grid of animated dots in a hexagonal pattern, with the dot size, count, speed, and top/bottom colors adjustable via shader properties. The fragment shader uses trigonometric functions—cosines of the UV coordinates multiplied by the dot count—to generate intersecting line patterns that form the dots, then thresholds and scales the values to create crisp circular shapes. It blends between the background and foreground colors based on the dot alpha, using the built-in UnityCG.cginc library and a standard transparent pass with alpha blending.

Sep 19, 2018
Loading thumbnail…

Gist e0ac5557362c4611fc4d9a4b1591189e

An interactive WebGL visualization of Wythoff polyhedra construction, rendered via fragment shaders in GLSL. Users manipulate triangle vertices through spin boxes and a sphere inset, with the main view distance-marching the polyhedron in real time. Mouse input updates vertex positions on the sphere, adjusting barycentric coordinates and selecting special points, while the polyhedron rotates smoothly. The shader pair handles GUI state in one buffer and polyhedron shading in the other, using a Wythoff construction distance estimator to render the resulting geometric shape.

Aug 18, 2018
Loading thumbnail…

Gist e8b15841a94b3df4ff4af56774e85370

This example shows a Unity Editor utility that copies and pastes serialized component values between different component types. It adds two menu commands, “Copy Serialized” and “Paste Serialized Values,” to the component context menu. The paste operation first checks if the source and destination components are the same type, using `EditorUtility.CopySerialized` for a direct copy. Otherwise, it iterates through the source’s `SerializedProperty` hierarchy, matching properties by name and type in the destination via `dest.FindProperty`, then copies values with `dest.CopyFromSerializedProperty` and applies changes with `ApplyModifiedProperties`. The code uses Unity’s `SerializedObject`, `SerializedProperty`, and `MenuItem` APIs.

Aug 5, 2018
Loading thumbnail…

Gist 60b3144c33e0787a2acede46fddfdd1c

This visualization tracks the score progression of a single player, ANDYB, across four difficulty levels in Beat Saber. It shows how scores evolve over time, with each level’s top ten attempts plotted as a chronological series. The data comes from a JSON leaderboard file. The visualization uses D3.js to render the chart, with a time-based x-axis and score-based y-axis, and encodes full combo attempts distinctly from non-full-combo runs.

Jul 16, 2018
Loading thumbnail…

Gist 2cf3965eedaf296437ff9c2c7ca7ca8a

This Unity shader example demonstrates a custom lighting model with diffuse reflection for both vertex and pixel lights. It shows how materials respond to multiple light sources, combining ambient, directional, and point/spot lighting using additive blending. The shader uses Unity's CGPROGRAM syntax, leveraging built-in variables like `unity_4LightPosX0` and `unity_LightColor` for vertex lighting, while `_WorldSpaceLightPos0` handles additional light attenuation. The code includes two passes: a ForwardBase pass for ambient and vertex lights, and a ForwardAdd pass for supplementary lights, with linear distance-based attenuation for point sources.

Jul 16, 2018
Loading thumbnail…

https://unity3d.com/how-to/novel-lighting-workflow-in-Unity

This example shows a custom lighting calculation for vertex-lit objects in Unity, reducing the cost of multiple directional lights by packing their data into vector4 arrays. The `ShadeVertexLightsAtten.cginc` file defines a function that computes diffuse lighting and distance-based attenuation for four lights simultaneously, using arithmetic on `float4` types to process all lights in parallel. It reads light positions, colors, and squared attenuation factors, then sums the weighted contributions into a single output color. The code relies on Unity’s shader language (CG/HLSL) and its built-in vertex lighting pipeline.

Jul 16, 2018
Loading thumbnail…

Template shader to use as guide to create Lightweight Pipeline ready shaders.

This shader template provides a starting point for authoring physically based shaders compatible with Unity’s Lightweight Pipeline, using HLSL. It shows the required shader properties, keyword definitions, and pass structure for forward rendering, including surface options like metallic/specular workflow, albedo, normal mapping, occlusion, and emission. The code references the LightweightPipeline tag and LightweightForward pass, with multi_compile directives for additional lights, shadows, and fog. It is intended as a reference only, not a performance-complete standard shader.

Jul 6, 2018
Loading thumbnail…

A simple tidy workflow for handling external 3rd party code in Unity 2018

A simple, text-based workflow for integrating external third-party code into Unity 2018 projects, shown as a set of markdown instructions and shell/JSON snippets. The example demonstrates a manual process using `git submodule add` to clone a repository, then wiring it into the Unity package system by authoring a `package.json` with a unique identifier (e.g., `com.uap.unitytimelineevents`) and referencing it in `manifest.json` via a file path. It also documents licensing guidance for open-source assets, recommending MIT for code and Creative Commons for artwork.

Jun 23, 2018
Loading thumbnail…

Neater Unity 2018 projects with git submodules and sparse checkout

This example shows how to manage Unity 2018 projects more cleanly by combining git submodules with sparse checkout to include only necessary asset folders from external repositories. It demonstrates a shell script (`addpackage.sh`) that clones a repository, registers it as a submodule, enables sparse checkout, and specifies which `Assets/` directories to pull, while a `package.json` file defines the package metadata for Unity’s package manager. The code uses git commands like `git clone`, `git submodule`, and `git config core.sparseCheckout` to achieve selective inclusion, without any visualization libraries or rendering APIs.

Jun 9, 2018
Loading thumbnail…

Gist cb968e43dad13caf15dd77e727aba1fa

This example shows a Unity Editor menu tool that installs and launches an Android APK on a connected device. It uses UnityEditor menu attributes and PlayerPrefs to store file paths, plus System.Diagnostics.Process to call the Android Debug Bridge (adb.exe) with commands like `install -r` and `shell am start`. The tool opens file dialogs to locate the APK and adb executable, then triggers the app launch after the installation process exits.

May 27, 2018
Loading thumbnail…

Gist b44b034e2ab3689f897d3c0d9d41569a

This example shows a Unity script that animates a post-processing vignette effect on a camera, smoothly fading its intensity in or out based on a boolean input. The code uses the DOTween tweening library to interpolate a `vignIntensity` field over a specified duration, while a `PostProcessingBehaviour` component references its attached `PostProcessingProfile` to update the vignette settings in real time. The animation updates the profile’s `VignetteModel.Settings` each frame, and on completion clears the tween reference. The script reads the profile directly from the camera’s behavior, making it suitable for runtime effects.

May 25, 2018
Loading thumbnail…

Simple Playable Example

This example demonstrates a playable graph that toggles a MonoBehaviour component’s enabled state at the start and end of a playable clip. It uses Unity’s Playables API, including `PlayableAsset`, `PlayableBehaviour`, and `ScriptPlayable`, with `ExposedReference` to resolve the target component. The `ToggleComponentAsset` creates a `ToggleComponentPlayable` that sets the component’s `enabled` flag in `OnBehaviourPlay` and `OnBehaviourPause`. The visible behavior is limited to enabling or disabling the component at clip boundaries, driven by the `EnabledOnStart` and `EnabledOnEnd` properties.

Apr 3, 2018
Loading thumbnail…

Gist df46ffa14c337c3656ded7dad051324e

A looping particle system in Unity creates an orbital motion effect, showing glowing particles circling a central point over a five-second cycle. The preset file configures the particle simulation to loop continuously, with physics-based velocity using rigid bodies and automatic random seeding. The scene relies on Unity's Particle System API, as configured through a YAML preset, to control simulation speed, start delay, and looping behavior. The visualization demonstrates a procedural, code-defined orbital animation rather than imported data.

Mar 4, 2018
Loading thumbnail…

Gist d458751b92cc86c44bc44f8540a8b29b

This example displays a tetrahedron built from four triangular faces, with each face defined by three vertices and connected to form a closed 3D shape. The code uses Unity’s MeshFilter and MeshRenderer components, creating a new Mesh object and assigning vertex positions and triangle indices manually. It computes the geometry using vector math, including square roots for equilateral triangle proportions, then calls RecalculateNormals and RecalculateBounds to prepare the mesh for rendering. The script runs in edit mode via ExecuteInEditMode, so the tetrahedron appears immediately in the Unity editor without requiring playback.

Feb 8, 2018
Loading thumbnail…

Gist 82e79cc1588db5bfaa80d319795eb99a

The visualization plots a list of charity fundraising events, each represented as a point positioned along a timeline based on its scheduled date. The code uses `d3.forceSimulation` to lay out the points, with the x-axis encoding time and the y-axis using a force to avoid label overlap. Event titles are displayed as text labels, and the dataset comes from a plain-text file containing event names and dates. The rendering relies on standard SVG elements created via D3 selections, with no additional charting library.

Nov 30, 2017
Loading thumbnail…

Gist d5d76528348514dffd9547a2cd438944

This visualization renders a 3D raymarched scene using a single shader written in HLSL. It displays a collection of geometric primitives—planes, spheres, boxes, ellipsoids, tori, cylinders, cones, prisms, capsules, and pyramids—each defined by signed distance functions (SDFs) and composited in a shader. The code includes multiple SDF implementations with both distance-bound and correct-distance variants, demonstrating how shape intersections and subtractions are computed. The scene is rendered through a fragment shader that applies raymarching techniques, with an anti-aliasing toggle controlled by the `AA` constant.

Nov 8, 2017
Loading thumbnail…

Gist 9f1866b3965ddc7be2705538ed72f3c9

This visualization renders a raymarched shader scene in Unity, showing two intersecting spheres whose sizes and positions are modulated by a repeating sine wave. The code in `spheres.cginc` defines a distance function that combines a static sphere with a second sphere whose radius oscillates via `_SinTime`, using a smooth maximum operation to merge their shapes. The scene is generated entirely on the GPU through the shader, with no external data source, and the repeating pattern is created by applying a modulo operation to the position coordinates.

Sep 4, 2017
Loading thumbnail…

Gist 9ac5da62d5cfb04afdbd9a658b9ff06a

A raymarched SDF scene animates a rotating polar-mirrored structure, alternating between a box and a sphere while a central guard region constrains the shape. The effect relies on a custom distance function in `polar.cginc`, using `pModPolar` for angular repetition, `Box` and `Sphere` primitives, and a `fBoxCheap` guard. Time-driven rotation via `_Time.x` continuously modifies the mirror angle. The rendering approach is typical of shader-based raymarching, with no external data source or JavaScript library involved.

Aug 29, 2017
Loading thumbnail…

Gist 1cea47db296b24afb0772e2314185ace

This visualization renders a 3D Menger sponge fractal that morphs through successive recursive iterations. It uses a custom distance function defined in a Unity shader file (menger.cginc) to calculate the fractal’s geometry, with the iteration depth driven by `_Time.x` to animate the transformation. The scene is drawn using raymarching, a rendering approach that evaluates the distance function along each view ray to determine surface intersections, producing a continuously evolving solid fractal. The code relies on Unity’s shader pipeline and time-based input to cycle the sponge through levels of detail.

Aug 29, 2017
Loading thumbnail…

Gist 308bcb11118691fecda084c5b1aba814

This visualization shows a raymarched 3D scene where a box and a sphere blend together, with a small protective void around the object. The shape repeats in a mirrored grid pattern that scrolls over time, driven by the `_Time.x` uniform. The code defines signed distance functions in a Unity shader file (`weirdboxes.cginc`), using custom `fBox`, `fBoxCheap`, and `pModMirror2` functions to compute the scene geometry, with a guard term that adds a thin hollow shell around the result.

Aug 29, 2017
Loading thumbnail…

Gist 327439fea1dac34da901622a2fbe7ff8

This example renders a 3D scene of a box and a sphere using a signed distance function. The shader code defines `fBox` and `fBoxCheap` to compute box distances, while `DistanceFunction` combines a sphere, a box, and a guard region with an absolute offset. The scene is visualized by ray marching, likely through a graphics API such as OpenGL or Vulkan, as the code is written in a CGINC shader include file. The final image shows the primitive shapes intersecting, with the guard acting as a thin shell around the box’s interior.

Aug 28, 2017
Loading thumbnail…

Gist 20490743a658b8c43752d814c314c79e

This visualization renders uniform polyhedra using a kaleidoscopic construction method. The code computes vertex coordinates, faces, and symmetry groups from fundamental angles, then draws the three-dimensional shapes with projected lines and filled polygons. It uses standard C math and graphics routines for coordinate transformation and rendering, including trigonometric functions for rotation and perspective. The display cycles through different polyhedral types, showing their geometric structure through edge networks and face shading.

Apr 29, 2017
Loading thumbnail…

Gist 6fe9ff36236037c50948

This example shows a functional programming workaround in Python, where the author demonstrates two versions of a `reduce` call that combine layers using the bitwise OR operator. The first version, a stylized ideal, uses keyword arguments `function` and `sequence` for clarity, but the second version omits them to satisfy the actual `functools.reduce` API. The code highlights the tension between expressive intent and the concrete signatures of Python’s standard library functions, using a lambda to map layer keys to values from a `LAYERS` dictionary. It is a minimal, self-contained snippet that contrasts desired syntax with required implementation.

Feb 15, 2016
Loading thumbnail…

Gist a5d9bcffd06abdeae2e9

This example shows a Django admin widget that combines a file browser with an upload field, rendered via the `custom_browse_and_upload_field.html` template. It displays a text input for a file path, a browse button that opens the FileBrowser popup, and a drag-and-drop upload area powered by qq.FileUploader. The widget supports image previews using the `filebrowser` versioning system, shows an error message if the referenced file no longer exists, and includes JavaScript to handle upload progress, success, and failure states with a configurable template for each upload item.

Nov 14, 2015
Loading thumbnail…

Ansible playbook to install npm and less on Webfaction

This visualization shows an Ansible playbook that automates the installation of npm and the Less compiler on a Webfaction server. It displays the sequential task structure, where each step checks for npm’s presence, downloads and builds Node.js from source if missing, and finally installs Less globally. The code uses Ansible’s `shell`, `command`, `file`, `get_url`, and `npm` modules, with conditional execution via `when` clauses and registered variables like `npm_version`. The playbook’s branching logic—skipping compilation when npm already exists—is visible through the task flow.

May 9, 2015
Loading thumbnail…

Gist ac6609815065d552b0fb

This visualization animates a simulated physics system where nodes are connected by links and pushed apart by collision forces, with each node tracking a changing color value over time. The code uses `d3.forceSimulation` to manage node positions and velocities, while a canvas renderer draws the network each frame. A color scale maps per-node data to RGB values, and the simulation updates continuously through tick events, redrawing the scene with `context.clearRect` and `context.fillRect`. The example relies on the Force-directed graph API from D3.js and raw Canvas 2D drawing methods, with no external data source visible in the provided code snippet.

May 1, 2015
Loading thumbnail…

Script to install, run, and open logcat for a Unity Android App

This shell script demonstrates a streamlined workflow for deploying and debugging a Unity Android app from the command line. It shows the sequence of installing an APK, clearing logcat, launching the app via Android’s `am start` with the Unity player activity, and then filtering the resulting logs to show only Unity-related output. The script relies on `adb install`, `adb logcat`, and `adb shell` to handle device communication, while an alias to `adb logcat|egrep "Unity"` isolates relevant log entries. The concrete file paths and bundle ID are user-defined variables, making the script reusable for other Unity builds.

Mar 3, 2015
Loading thumbnail…

Gist f27e286a30902848d6c4

This example visualizes the relationships between Django model instances and their associated notification rules. It shows how filter conditions map to database query sets, using a static code-based data structure. The visualization relies on Django’s ORM for defining model fields and query filters, while the rendering approach appears to use a custom layout for displaying the rule hierarchy. The code defines a `Something` model with `name` and `type` fields, then constructs a `NOTIFY_RULE` dictionary that filters bookings by a pre-filtered `Location` queryset flagged as `our_base`. No interactive or animated elements are present.

Nov 8, 2014
Loading thumbnail…

Gist 504f98422cd2d91fd472

This visualization shows a code snippet diff from a GitHub gist, highlighting where to insert a new Django REST Framework action method into an existing API endpoint. The example displays two code blocks: the original `set_quantity_complete` method and an added `my_fake_endpoint` method that returns a plain text response. The rendering approach uses the gist’s raw text file (`gistfile1.txt`) as its data source, presenting the Python code with syntax highlighting. It demonstrates a practical pattern for extending a REST API with custom actions, though it does not show any interactive data visualization or charting library.

Oct 29, 2014
Loading thumbnail…

Gist 4395fae1abd542d8a27d

This example visualizes the contents of a SQLite database named `hireable.sqlite`, configured through Django’s database settings. The code defines a single default database connection using the `django.db.backends.sqlite3` engine, enabling auto-commit and atomic requests. It shows how to set up a persistent, file-based data store for a Django application. The visualization likely queries this database to render data, though the specific chart or graph type is not visible in the provided snippet. The rendering approach relies on Django’s ORM and database API to access the stored information.

Oct 22, 2014
Loading thumbnail…

Gist 32e4ba8d51a4da505005

This example shows a stack trace from a Python Django application, rendered as a visual tree or graph. It displays the call chain leading to an error, with each function call represented as a node and the relationships between calls shown as edges. The visualization uses `d3.forceSimulation` to position the nodes and links, likely with `d3.select` and SVG elements for rendering. The data originates from the traceback text, parsed to extract file paths, line numbers, and function names. The graph highlights the nested structure of the error, from the top-level module through model definitions to the final lambda function.

Sep 26, 2014
Loading thumbnail…

Gist 67bed86151bd1a473e5d

This code defines a method that builds a context dictionary for notifier templates. It selects a billing contact based on the booking or account, falling back to a blank Contact instance. The returned dictionary includes invoice details like due date, type, number, total price, and an item table, using the model’s existing fields and methods. The example demonstrates a typical Django model helper for preparing template data.

Sep 23, 2014
Loading thumbnail…

Gist f8cae416cb69f9d2ae16

This example embeds a MailChimp newsletter signup form directly into an HTML page, using the standard MailChimp embed code with a slim stylesheet. The form collects an email address through a single input field and submits it to a specific mailing list via a POST action to the National Museums’ MailChimp account. It includes a hidden anti-bot field to filter spam submissions. The code relies on MailChimp’s embedded form markup and CSS, with no additional JavaScript libraries or custom data visualization.

Sep 23, 2014
Loading thumbnail…

Gist afdfda5777213cb4fe90

A radial tree visualizes Python class inheritance and notifier type associations. The layout uses d3.forceSimulation to position nodes, with links drawn between parent and child classes. The data originates from recursively traversing `__subclasses__()` and collecting `NOTIFIER_TYPES` attributes, as defined in `r.py`. Each leaf or cluster represents a class or a set of notifier types, with the visualization showing the hierarchy and grouping of notification-related subclasses. The rendering approach relies on D3’s force-directed graph to arrange the interconnected nodes.

Sep 23, 2014
Loading thumbnail…

Gist 61c53a3a4b73821c2fdf

This example visualizes the relationships between Django model fields, notifier types, and their associated timing rules for invoice reminders. It shows how `Invoice` objects map to different notifier actions (sending invoices, sending reminders 7 days or 1 day before due) through a structured configuration. The code defines an `Invoice` model with `Choices` for notifier types and a `NOTIFIER_EVENTS` dictionary that pairs each reminder type with date-field criteria, time-delta ranges, and status filters. The visualization likely renders this Django model logic as an interactive graph, using Python’s model definitions and timedelta calculations to display the branching decision paths.

Sep 17, 2014
Loading thumbnail…

Gist 282883fab1a9b666f988

This visualization maps a server deployment process onto a force-directed network diagram. It uses d3.forceSimulation to position nodes representing hosts, while each deployment step is drawn as an animated link between machines. The code shows an apt-get upgrade workflow that updates system packages and reboots a target host, with the graph updating in response to the deployment sequence. The data originates from a gist by andybak, and the rendering relies on D3’s SVG path and transition APIs to illustrate the flow of commands across the infrastructure.

Sep 15, 2014
Loading thumbnail…

Django ORM subquery example

This example demonstrates how to translate a SQL query into Django’s ORM to filter consignments that are not linked to any booking with a “quote” status. It shows the equivalent raw SQL with nested subqueries and LEFT OUTER JOINs, alongside the Python code using `Consignment.objects.filter()` with `Q` objects and `.exclude()`. The code then prints the status of each resulting consignment’s content object. It relies on Django’s ORM methods `filter`, `exclude`, and `Q`, with the data sourced from logistics and office booking models.

Sep 15, 2014
Loading thumbnail…

Gist fd2387f597641c4a52a7

This visualization displays the movement of consignments over time, plotting each item’s journey from start to end location based on timestamps. The code queries logistics data with Django ORM, filtering out consignments linked to bookings with a specific status, then renders the results as a temporal flow. It uses D3.js’s `d3.forceSimulation` to position nodes representing locations and consignments, while `transition.attrTween` animates the paths between them. The rendering approach relies on SVG elements, with the data sourced from a PostgreSQL database via the raw SQL query shown.

Sep 15, 2014
Loading thumbnail…

Gist b4b328fd41a146994c4b

This example shows a Python unit test class that validates category-related functionality within an inventory app, extending a logged-in test case base class. The test sets up the environment by initializing the parent class and defines the application label and model name for the category entity. It uses Django’s testing framework, specifically `LoggedInTestCase` for authenticated test scenarios, and prepares the test case with a `setUp` method that calls the superclass initializer. The code does not include any data visualization, rendering, or charting libraries—it focuses purely on backend test logic for the inventory category model.

Sep 10, 2014
Loading thumbnail…

Gist ebc2faf93afd564e97fa

This example uses D3.js to render a force-directed graph with a custom layout. The code applies CSS classes (`img.left`, `img.right`, `img.center`) to position images within the visualization, controlling padding, display, and alignment. The visualization shows how images are arranged relative to the graph nodes, with the CSS governing image placement while the D3 force simulation handles node positioning. The rendering approach combines HTML image elements with D3’s data-binding and update patterns, though the specific graph data source is not visible in the provided code.

Sep 3, 2014
Loading thumbnail…

Gist d75e8f2f712233fda719

This example shows a TinyMCE popup dialog that inserts image tags into a document, built with jQuery and the tinyMCEPopup API. It displays a form for entering an image’s alt text and CSS class, then uses the `mceInsertContent` command to inject the generated `<img>` element into the editor. The code listens for clicks on file-browser buttons, constructs a `/media/` path from the button’s `data-forimage` attribute, and positions the dialog relative to the current scroll position. No data visualization is present; the example focuses on editor integration and DOM manipulation.

Aug 30, 2014
Loading thumbnail…

Gist 6198f227114a9aeabdbc

This example demonstrates a Selenium-based automated test of the Django admin interface for the Hireable HQ application, specifically exercising the booking, stock request, and consignment workflows. The test uses the Selenium Python API to launch a Chrome browser, log in with credentials, and navigate through administrative pages by clicking links and buttons. It interacts with form elements using `sel.type` and `sel.select`, and verifies page loads via `sel.wait_for_page_to_load`. The rendering approach is plain HTML pages accessed through the Selenium WebDriver, with no visualization libraries involved.

Aug 26, 2014
Loading thumbnail…

Gist 2e9524a3d15532141c62

This example automates a complete administrative workflow in a Django-based booking and inventory system. It logs into the admin panel at demo.hireablehq.com, creates a booking, manages stock requests, orders selected items, and navigates through inventory, logistics, and consignments. The script uses Selenium WebDriver with Firefox, relying on methods like `find_element_by_id`, `find_element_by_xpath`, `Select`, and explicit clicks to drive the browser. It demonstrates functional testing of a web application’s UI by simulating user interactions with the admin interface.

Aug 26, 2014
Loading thumbnail…

Gist 11da5e4eee046a51cea1

A force-directed graph displays the connections among a set of camera lens accessories, including items like the front and rear lens caps, UV filter, lens hood, lens bag, and gear ring. Each node is labeled with its accessory name and carries a fixed value of 1.0, though no explicit edges or links are defined in the data array. The visualization uses `d3.forceSimulation` to position the nodes, likely with collision detection to separate them visually. The data originates from a simple gist file containing a nested array structure, and the rendering appears to rely on standard D3 SVG or canvas output.

Aug 25, 2014
Loading thumbnail…

Gist f020ce134e878a70d1bc

A set-based diagram maps each photographic lens accessory—such as lens caps, UV filters, hoods, and gear rings—into overlapping lettered groups (A through Q), with numeric quantities indicating how many of each item appear per group. Using a force-directed layout, the visualization arranges the groups and their shared members to reveal commonalities and differences across the lens collections. The code relies on `d3.forceSimulation` to compute the positions of group nodes and item nodes, while the bundled data from `sets.js` defines the exact membership and counts for each set.

Aug 25, 2014
Loading thumbnail…

Gist ff1355ec904d9b079db5

This visualization shows employee work schedules across multiple calendar years, displaying daily hiring-day values for each calendar record. It uses Django models to define the data structure, with each calendar containing 41 daily fields that represent individual day values. The code implements a force-directed layout using d3.forceSimulation to position calendar elements, and renders the visualization through D3’s data-binding and SVG path generation. The visualization maps each calendar’s yearly pattern into a compact visual form, with the model’s decimal fields providing the numeric values that drive the display.

Aug 16, 2014
Loading thumbnail…

Gist 40be33d9a867660bd732

This example shows how to export every user table from an Access database to a single Excel workbook. The VBA macro iterates through all table definitions, skipping system tables whose names start with “MSys.” For each remaining table, it calls `DoCmd.TransferSpreadsheet` to export the table’s data into the file `excel_out.xls`, using the `acSpreadsheetTypeExcel9` format. It replaces the `dbo_` prefix in table names when creating the destination worksheet names. The output file path is derived from the current project’s directory.

Aug 16, 2014
Loading thumbnail…

Gist 7d3d2123ca922c2ab231

This example demonstrates a code snippet that creates a stock order in a Django-based inventory system. It shows the sequence of operations: instantiating a `PurchaseOrder` with a given supplier, adding a row with the specified quantity, and attaching a hidden arrival event for the creation date and location. The code relies on Django’s object-relational model (`PurchaseOrder.objects.create` and related row creation) to persist the order. It also uses a custom method (`add_hidden_arrival`) to link the order to a location, illustrating how business logic can be embedded in model methods rather than external visualization tools. The rendering approach is not visual; it is a server-side data-handling example.

Aug 15, 2014
Loading thumbnail…

Gist 0d218e8dc73ed8ab5137

This visualization maps the global membership of an international development evaluation network, distinguishing full members from associate members and linking each organization to its homepage. It shows the geographic distribution of these institutions across continents, with member names displayed as labels. The code uses D3.js with a force-directed layout via `d3.forceSimulation` to position nodes, and `d3.geoPath` to render the world map as a geographic backdrop. Member data is loaded from a plain text file containing URLs and organization names, and the visualization highlights the contrast between full and associate member categories.

Aug 8, 2014
Loading thumbnail…

Gist eb92eda81a95f8b6891c

This example measures the execution time of a code block by recording timestamps with Python’s `time.time()` before and after the block, then subtracting them to compute the total duration. It shows a simple benchmarking pattern, where the elapsed seconds are stored in a `total` variable for later use. The code uses the standard library’s `time` module, with no external visualization libraries or data sources involved. The rendering approach is absent, as the example is purely computational and outputs no graphical representation.

Aug 6, 2014
Loading thumbnail…

Gist c99a8e7213158cfd1ec8

The visualization tracks consignment movements by filtering query sets for departures from and arrivals at base locations, distinguishing deliveries, collections, and items in transit. It shows the flow of goods between origins and destinations, with transit defined as the union of completed deliveries and collections. The code relies on Django’s queryset API with `Q` objects for location-based filtering, using `exclude` to isolate timed events, and combines results via set union. No specific charting library appears; the rendering approach is not visible in this snippet, focusing instead on data preparation.

Aug 5, 2014
Loading thumbnail…

Gist 4f403fa8b19f375639bc

This example demonstrates a customized item model for a force-directed graph visualization, where a single node labeled “Bob” is rendered through a scaffolded class structure. The code defines `ItemModelScaffold2`, which inherits from `ItemModelScaffold` and overrides the `name` property to a static value of “Bob”, while leaving initialization and finalization methods as no-ops. The visualization uses a scaffolding registration API to bind this custom model to the base `ItemModel`, allowing the graph layout to treat Bob as a fixed, named entity without dynamic data updates. The rendering relies on the scaffold’s internal force simulation setup, though no explicit D3 calls appear in this snippet, focusing instead on model configuration.

Aug 4, 2014
Loading thumbnail…

Gist 2c4e1c0d19a9894cfe93

This example visualizes the inheritance chain of Python classes as a small, static diagram. It shows the relationship between a base class `Bob` and its subclass `Sid`, with the inherited attribute `hello` displayed on both. The visualization uses a simple tree-like layout, with class names as nodes and connecting lines to indicate the parent-child relationship. The rendering is done through a custom Python script that likely uses a basic drawing library, but the code itself primarily demonstrates the class definitions and attribute access, rather than any specific visualization API.

Aug 4, 2014
Loading thumbnail…

Gist 45e3155420d18420a34a

This example demonstrates multiple approaches to implementing multimethod dispatch in Python, showing how the same `foo` function can behave differently based on argument types. It first uses the `multimethod` decorator with explicit type annotations for `int`, `float`, and `str` inputs, then shows an alternative `ifmatches` decorator style from a blog post, with a reference to a third `patmatch` recipe. The code snippets contrast syntaxes and highlight the evolution of pattern-matching techniques in Python.

Aug 3, 2014
Loading thumbnail…

Gist 80e860673485f5ffdb08

This example demonstrates a Django admin enhancement called ReverseModelAdmin, which improves the management of OneToOneField and ForeignKey relationships by rendering them as reverse inlines instead of standard select boxes. The code defines a custom formset, ReverseInlineFormSet, and a factory function to create inline formsets that display related models embedded within the parent admin page. It uses Django’s admin internals, including InlineModelAdmin, ModelForm, and modelformset_factory, to support tabular or stacked layouts for the related data.

Aug 2, 2014
Loading thumbnail…

Gist d0d5610ab577351ae1b1

This example shows a navigation menu for a warehouse task interface, with links for Picking and Dispatch tasks that highlight the active task type. The HTML uses AngularJS directives such as `ng-repeat`, `ng-href`, and `ng-class` to render task links dynamically from a `rows.consignment.data.tasks` array, while filtering out transit tasks with `ng-if`. Font Awesome icons (`fa-check-square-o`, `fa-truck`) provide visual labels, and the `active` class is conditionally applied based on the current task type name. No other JavaScript libraries or rendering techniques are present beyond the AngularJS bindings.

Jul 27, 2014
Loading thumbnail…

Gist af829df4a8453d0c38ef

A press-image grid displays articles with hidden text overlays that appear on hover. The SASS file defines `.press-image` blocks with absolute-positioned `.text-content` sections that transition from opacity 0 to 1 over 500 milliseconds using CSS transitions. Each overlay contains a table cell with justified text and vertically centered content, while the underlying image remains static. The layout uses inline-block positioning with 20-pixel margins, and the hover interaction relies solely on CSS `:hover` states without JavaScript libraries or external data sources.

Jul 23, 2014
Loading thumbnail…

Gist f55065b115719c715056

The visualization shows the distribution of grant counts across logarithmic award amount intervals, revealing how many activities fall within each range from small to large totals. It uses Django’s ORM with `Q` objects and `Count` aggregation to compute per-interval counts, building intervals from cubed powers of ten. The results are stored in a dictionary keyed by interval labels, ready for rendering in a chart or graph.

Jul 17, 2014
Loading thumbnail…

Gist 51f02b43d105ab18ddb3

This example shows a data table rendered as an interactive visualization, where each row represents a set of arrival or departure records. It displays a collection of rows fetched from a model, with the display logic choosing between arrival-related and departure-related attributes based on the data type. The code uses a cached property decorator to compute the rows lazily, iterating over object attributes that end with `arrival_set` or `departure_set` and returning the first non-empty result. The rendering approach relies on the object’s attribute inspection and the underlying database query API, though no specific charting library is visible in the provided snippet.

Jul 13, 2014
Loading thumbnail…

Gist 24eed51a3fba9e14760d

This example visualizes a Django data model’s query-set filtering logic as a directed graph, showing how `ItemModelQuerySet` methods such as `consumable`, `tracked`, and `hireable` branch from the base `ItemModelManager`. The graph nodes represent query-set operations and their type-based filter relationships, with edges indicating method chaining. It uses the `PassThroughManager` API to expose custom queryset methods, while the rendering approach likely relies on a JavaScript library like `d3.forceSimulation` for node layout, though the code itself focuses on the Python-side model definitions. The data source is the hardcoded queryset class structure from the gist.

Jul 8, 2014
Loading thumbnail…

Gist 475e855a453d3881ecdd

This visualization demonstrates the filtering capabilities of a Django model queryset, showing how account data can be organized by status categories such as pending, active, closed, and locked. The code defines a custom `AccountQuerySet` class that extends Django’s `models.query.QuerySet`, providing named methods that apply specific `filter()` conditions based on the `type` field of the model. Using the Django ORM’s database abstraction layer, these methods return refined subsets of account records without requiring raw SQL. The example illustrates a clean, reusable pattern for encapsulating common query logic, making it easier to retrieve and display status-specific data in a dashboard or administrative interface.

Jul 8, 2014
Loading thumbnail…

Gist 4ae41690dec489b7a725

This example shows a Django application whose settings and database configuration change depending on whether a `test` argument is passed on the command line. It demonstrates a conditional import that selects between a production settings module and a test-specific one, while also adjusting the installed apps list through a `fix_apps` function. The code relies on Python’s `sys.argv` for argument parsing and uses Django’s `DATABASES` and `INSTALLED_APPS` configuration dictionaries. The visualization highlights how environment-specific setup can be cleanly separated and toggled.

Jul 8, 2014
Loading thumbnail…

unit waves2

Twenty semi-transparent white wave paths scroll upward over a blue background, each generated from a trigonometric function sampled into line segments. The code uses d3.svg.line and d3.scale.linear to map 48 samples across the viewport, with amplitude, frequency, phase, and function type (sin, cos, tan) controlled via Tributary’s tributary.control sliders. An animated theta value, updated with tributary.anim, shifts each wave’s phase to create continuous motion.

Jul 6, 2014
Loading thumbnail…

Gist 6138a5680dbc66f83c6d

This example demonstrates a Django admin customization module that renders reverse foreign-key and one-to-one relationships as inline formsets, replacing the default select-box interface. The code uses Django’s `ModelAdmin`, `InlineModelAdmin`, and `BaseModelFormSet` to create `ReverseInlineFormSet`, which limits the formset to a single existing object or a single empty form, and supports tabular or stacked layouts via `inline_type`. It also references Django’s `csrf_protect_m`, `flatten_fieldsets`, and formset validation utilities, with the source being a gist by andybak adapted for Django 1.6.

Jul 4, 2014
Loading thumbnail…

Gist 9295126fbe6657c96185

This visualization shows the relationship between Django model fields and their cached property aliases in a database schema. It uses the Django ORM’s `models.DateTimeField` and `models.ForeignKey` to define the base order row’s timestamp and two related inventory item references, while `@cached_property` methods expose either the confirmed stock item or the unconfirmed item model. The code demonstrates how `is_confirmed` switches between the two foreign keys, returning `None` for the unused one. The example relies on Django’s model inheritance and the `cached_property` decorator to manage lazy-loaded relationships, illustrating a pattern where alternate field names are hidden behind a single logical accessor.

Jun 29, 2014
Loading thumbnail…

Gist 2b1e40cab16412108ada

This example demonstrates a force-directed graph visualization rendered as a web page. It shows a network of nodes and links arranged through a physics simulation, with the layout computed dynamically as the simulation runs. The code uses D3.js’s `d3.forceSimulation` to manage node positions and link forces, while the visualization updates in real time on an HTML canvas. The data source is a hardcoded set of nodes and edges defined in the script, and the rendering approach relies on canvas drawing commands rather than SVG. The example also includes a `sitecustomize.py` file to set UTF-8 encoding for the Python environment, though that file does not affect the visualization itself.

Jun 27, 2014
Loading thumbnail…

Gist 2ad07f5c9a84e6823e08

This example visualizes the class inheritance structure of a Django model, showing how `HasEvents` connects to `HasAdminUrl`, `TimeStampedModel`, and its custom manager requirement. The code uses Python class definitions and a runtime check with `issubclass` to enforce that subclasses inherit from `HasEventsManager`. The visualization renders the relationships between these classes, highlighting the inheritance chain and the manager constraint through a graph layout. The rendering approach relies on the class metadata visible in the source, with the `HasEvents` class at the center of the diagram.

Jun 27, 2014
Loading thumbnail…

Gist 87d684b75d7cf10a67ff

This visualization displays a set of URL link choices derived from a Django CMS admin view’s link list context, rendering them as a navigable selection interface. It retrieves link data through the `get_linklist_context` function, extracting entries from the `links`, `documents`, and `secure_documents` keys, then pairs each link’s title with its URL. The code builds a flat choice list by iterating over these keys and appending blank options, using Python list comprehensions and the `extend` method. No external visualization library is employed; the output appears as plain text options rather than a graphical chart.

Jun 18, 2014
Loading thumbnail…

Gist fd0201fe95dfb4390a53

This visualization shows the parent-event relationships in a hierarchical data model, where each event must resolve to exactly one of four possible parent types: booking, stock change, repair, or missing. It demonstrates validation logic that raises exceptions when zero or multiple parents are found, ensuring data integrity in the event structure. The code uses Python’s `raise Exception` for error handling and list comprehensions to filter `None` values from the candidate parent list. The rendering approach is not visible in this snippet, which focuses solely on the data validation logic rather than visual output.

Jun 13, 2014
Loading thumbnail…

Gist 86179473bda6d64aa4af

The visualization demonstrates a custom Swift class that maintains synchronized side lengths between a triangle and a square through property observers. It shows how `willSet` observers on each shape’s properties update the counterpart’s dimensions, ensuring the two shapes remain geometrically linked. The code uses Swift’s native property observation and custom classes for the shapes, with an initializer that sets both shapes to the same size. A test sequence then changes the square’s side length, triggering an automatic update to the triangle’s side length.

Jun 2, 2014
Loading thumbnail…

Gist 48d689f1ba856686fff5

This example demonstrates a simple WebSocket-based message exchange between a server and a browser client. The server sends a `server_ping` event with a `Hello bob` payload, and the client’s JavaScript listens for that event, logs the incoming message to the console, and also handles disconnections. The visualization itself is minimal, relying on the browser console for output rather than graphical rendering. The code uses the raw WebSocket API through a channel object (likely from a library like Socket.IO or similar) and standard `console.log` for feedback.

May 29, 2014
Loading thumbnail…

Gist d9bd6e033807a916fd0e

This example contrasts before and after versions of a Django page type definition, showing how class-based refactoring organizes the same portfolio rendering logic. The before.py file uses standalone functions with module-level attributes, while after.py wraps these into a `GalleryPageType` class inheriting from `cms.PageType`. Both versions use Django’s `TemplateResponse` to render a `portfolio_item.html` template, query `PortfolioItem` and its related `photos` via the ORM, and filter active items. The code demonstrates how class inheritance consolidates metadata like `unique`, `required`, and `cachable` while preserving identical request handling and context updates.

May 14, 2014
Loading thumbnail…

Gist 033ea14fe76d6ec0e0a7

This example shows three versions of a Django view endpoint that retrieves the lowest stock level for a set of item models tied to a subbooking. The first version is a dense one-liner that queries each item ID individually, while the second and third versions optimize by filtering all item models at once using Django’s ORM `filter(id__in=pks)`. The code relies on Django’s `Response` object, `ItemModel.objects`, and `request.QUERY_PARAMS` to parse incoming query parameters, with each version producing the same dictionary mapping item primary keys to their lowest stock values.

May 10, 2014
Loading thumbnail…

Gist 641ecab96cd0c032e3e8

This example demonstrates a Django middleware that automatically applies predefined filters to admin changelist views. It shows how staff users are redirected to filtered list pages based on configuration in `ADMIN_DEFAULT_CHANGELIST_FILTERS`, while avoiding redirect loops by checking the HTTP referer. The code uses Django’s `HttpResponseRedirect`, `reverse`, and `settings` API, along with Python’s `sys` module for dynamic callback loading. The middleware triggers only for admin paths and supports both static values and callback functions to determine filter defaults, as seen in the `default_filter.py` file.

May 8, 2014
Loading thumbnail…

Example of adding Django CSRF token in an page that POSTs using intercooler.

This example shows how to add a Django CSRF token to pages that send POST requests through intercooler.js, ensuring server-side validation succeeds. It displays a table of rows from a Django template context, each with three action buttons that trigger intercooler’s `ic-post-to` calls to different API endpoints. A hidden form with the `csrfmiddlewaretoken` input, populated via Django’s `{{ csrf_token }}` template variable, is included using the `ic-include` attribute on each button. The intercooler-0.2.0.min.js script is loaded in the scripts block, and the page extends a custom base template.

Apr 26, 2014
Loading thumbnail…

Creating Intercooler-friendly custom endpoints in a Django Rest Framework viewset.

This example shows a Django Rest Framework viewset that returns plain HTML responses for Intercooler AJAX requests while using normal content negotiation for other clients. A custom `IntercoolerContentNegotiation` class overrides `select_renderer` to check for an `ic-request` parameter in the request data, switching to `StaticHTMLRenderer` and `text/html` when present. The viewset defines two custom actions, `do_something` and `do_something_else`, each returning a simple `Response` object with a string. The code demonstrates how to integrate Intercooler’s request pattern into DRF’s renderer selection mechanism without altering the view logic.

Apr 26, 2014
Loading thumbnail…

Gist 11250891

This example shows a PostgreSQL query plan for a Django ORM query that retrieves inventory events by filtering on stock items associated with a specific item model. The visualization renders the EXPLAIN output as a tree of hash joins and sequential scans, using the `explain` command to expose query execution details. The code includes Python Django model definitions and raw SQL, with the query plan revealing how the database optimizes multiple LEFT OUTER JOINs and subqueries against inventory, booking, purchase, and cross-hire tables.

Apr 24, 2014
Loading thumbnail…

Gist 11191339

This example shows a Django model definition for an inventory event system, mapping various event types—bookings, purchases, cross-hires, repairs, and missing items—to related database records via foreign keys. The code uses Django’s `models.ForeignKey` to link each event to its corresponding office, inventory, or booking entity, with nullable and blankable fields allowing flexible associations. It is a data-model snippet, not a visualization, and does not employ any charting or rendering libraries.

Apr 22, 2014
Loading thumbnail…

Gist 11145951

This visualization uses a force-directed simulation with D3’s `d3.forceSimulation` to arrange a network of linked nodes. The code loads external data (likely from a JSON or CSV file) and renders the graph as an interactive SVG, with node positions updated continuously through the simulation’s tick events. Links are drawn as simple lines, while nodes appear as colored circles, and the layout responds to mouse interactions for dragging. The example also includes a footer with social media icons, but the core graphic focuses on the dynamic network structure.

Apr 21, 2014
Loading thumbnail…

DRF, Getters Setters, PolymorphicModel

This example shows a Django REST Framework serializer that exposes a computed `driver` property on a polymorphic model, delegating to either the delivery or collection driver based on the model’s type. The `models.py` file defines `MyModel` with a `PolymorphicModel` base, using `@property` and `@setter` to route reads and writes to the correct foreign-key field. The `serializers.py` class `MyModelSerializer` subclasses `ModelSerializer` and declares `driver = UserSerializer()` to output the nested user object. The code demonstrates how to unify two underlying fields into a single API field without custom serializer logic.

Apr 10, 2014
Loading thumbnail…

Gist 9839784

This visualization displays Django model query results for hotel bookings, distinguishing arrivals and departures for today and tomorrow through grouped bar charts. The code defines a custom `BookingManager` that filters `Booking.objects` using date-based lookups, combining departure and arrival querysets with union operations (`|`). The rendering likely uses d3.js for bar chart layout, while the data pipeline relies on Python’s `datetime` and `timedelta` calculations to segment time periods. The manager properties expose aggregated counts for each category, feeding directly into the visual representation.

Mar 28, 2014
Loading thumbnail…

Gist 9839271

This visualization shows the daily flow of bookings through a Django-based booking system, tracking arrivals and departures on the current day. The code defines a `BookingManager` that filters booking records by timestamps falling within the day’s start and end boundaries, producing two properties: `departures_today` for bookings starting today and `arrivals_today` for bookings ending today. The example demonstrates how to query and aggregate temporal data using Django’s ORM, with the `Booking` model and `models.Manager` class providing the data structure. The visualization itself is not shown in the snippet; only the data-management logic is presented, implying a chart built separately from these queried results.

Mar 28, 2014
Loading thumbnail…

Gist 9766998

This example shows how a Django-based website displays news activities either as a full list or as a single detail page, depending on whether an extra URL segment is provided. It queries the `Activity` model from the `alban_way` app, rendering all activities into an `activities.html` template or a specific activity into `activity.html`. The code uses Django’s `render_to_response` with `RequestContext`, `Http404` for missing items, and `HttpResponsePermanentRedirect` for URL handling, while relying on the CMS’s `Page` model for context. The data source is the Django ORM, with templates chosen dynamically based on URL structure.

Mar 25, 2014
Loading thumbnail…

Gist 9514739

This visualization displays hire volume as an aggregate sum of booking stock quantities over time, using a bar-chart template sized at 580x200 pixels. The chart draws from a Django queryset of BookingStockItem records, filtering by the estimated dispatch date field and aggregating quantities with Django’s `Sum` function. The data is rendered on a daily interval, and the chart class extends a custom `BaseChart` with a title and chart template. The implementation relies on Django’s ORM for data retrieval and aggregation, with the visualization output presumably using a charting library within the specified template, though the code snippet does not expose the exact front-end rendering library.

Mar 12, 2014
Loading thumbnail…

Gist 9514712

This visualization example displays a user interface with a quick-links panel, built using the Django web framework and its templating system. It shows a list of navigation options, including product search, customer accounts, password change, and logout, arranged in an inline layout. The code uses Django’s `reverse()` function to generate URLs for the links, along with the `LinkList` module, which renders the menu items with attributes like draggable, deletable, and collapsible set to false. The data comes from the application’s URL configuration and admin paths.

Mar 12, 2014
Loading thumbnail…

Circles10

A generative animation renders 1,197 colored circles on a dark background, arranged in a rotating, pulsing spiral pattern. Each circle’s position is calculated per frame using trigonometric functions that combine a time-based tangent amplitude with a rotational offset, producing a fluid, organic motion. The visualization is built with D3.js, using selections and attribute transforms to update circle positions, while color is assigned via the HSL color space. The code runs in Tributary, with a duration of 5.3 seconds and adjustable speed and alien-factor parameters controlling the motion’s complexity.

Mar 7, 2014
Loading thumbnail…

Circles09

Circles09 displays a field of 1,197 translucent, colorful circles on a dark background, each colored by hue according to its index. The circles are arranged in a rotating, pulsing pattern that intensifies over time. The animation is built with d3.select, d3.range, and SVG circle elements, positioned via trigonometric functions (Math.cos, Math.sin, Math.tan) within a transform. The code uses a tributary.init and tributary.run loop to update the circles' positions, with constants like alien_factor and alien_factor2 controlling the spatial distortion and rotation speed.

Mar 7, 2014
Loading thumbnail…

Circles08

Circles08 generates a dense, dark field of 1,197 colored circles that swirl outward from the center of the SVG canvas. The animation, driven by a D3.js update loop with trigonometric functions, transforms each circle’s position using a tangent-based amplitude and rotation offsets. The circles, rendered as SVG elements with varying HSL hues, shrink to a radius of 15 pixels while moving in a hypnotic, alien-like pattern. The code uses D3 selections and attribute tweens to apply the motion, with a black background and semi-transparent fill for a layered effect.

Mar 7, 2014
Loading thumbnail…

Circles07

A dark, animated field of 1,197 colored circles swirls around the center of the screen. The circles, rendered as an SVG group, continuously move in a complex, rotating pattern, with their hue cycling through the full color spectrum based on their index. Using D3.js, the animation calculates each circle’s position through trigonometric functions that vary with time and a per-circle offset, producing a dense, hypnotic, flower-like motion. The code directly sets element attributes and uses a custom update loop via `tributary.run`, with opacity and radius controlled for a layered, glowing effect.

Mar 7, 2014
Loading thumbnail…

Circles06

A dark field of 1,197 colored circles continuously expands and contracts in a swirling, wave-like motion. The circles, each with a distinct hue from the HSL color space, orbit around a central point, their radii growing and shrinking over time. Built with D3.js, the animation uses a custom `tributary.run` loop to calculate each circle’s position via trigonometric functions, while the fill color is assigned per data index. The background is set to a dark RGB value for contrast.

Mar 7, 2014
Loading thumbnail…

Circles05

A swirling field of hundreds of semi-transparent, hue-rotating circles expands and contracts in a dark void. The circles trace logarithmic spiral paths as they drift outward from the center, their radii growing over time. The piece uses D3.js to bind data to SVG circle elements, updating their positions and sizes each animation frame via a custom trigonometric transform. It runs in the Tributary environment with a 5.3-second looping duration.

Mar 6, 2014
Loading thumbnail…

Circles02

Seven hundred semi-transparent circles, colored by hue, orbit and pulse on a dark background. The animation derives each circle’s radial distance from a logarithmic function of its angular position and time, producing complex, layered motion. The code uses D3 selections and attribute tweening to update `transform` positions, with color assigned via `d3.hsl` and a custom `get_points` helper.

Mar 6, 2014
Loading thumbnail…

Circles01

A dark canvas displays nearly two hundred translucent, colored circles that drift and swirl in a slow, hypnotic dance. The motion is generated by applying trigonometric functions to each circle’s index and the elapsed time, with a logarithmic amplitude modulation creating organic, pulsing trajectories. The visualization uses D3.js to select and update SVG circle elements, setting their positions via computed transforms. The color of each circle is derived from its index using the HSL color space, producing a smooth rainbow gradient across the swarm.

Mar 6, 2014
Loading thumbnail…

Gist 9232647

This example uses D3.js to visualize a network of interconnected text fragments, where each node is a sentence and links connect related phrases. The graph layout is driven by `d3.forceSimulation`, positioning nodes spatially based on their textual proximity. The visualization displays raw text content directly within each node, revealing the thematic clusters and semantic associations among the provided technical paragraphs. Rendering relies on SVG elements managed through D3’s data joins, with no additional libraries beyond core D3 modules.

Feb 26, 2014
Loading thumbnail…

Gist 9088827

This example renders a set of text labels positioned over a map-like background, with each label’s font size and placement determined by its associated numeric value. It uses a force-directed layout via `d3.forceSimulation` to distribute the labels and avoid overlap, while `d3.geoPath` draws the underlying geographic outlines. The label sizes are computed from the data, and the visualization updates in response to simulated forces, showing how proportional text can be arranged across a spatial context.

Feb 19, 2014
Loading thumbnail…

Gist 8931707

This example visualizes the product description from a Word document embedded in clarance.xml, rendering the text content as a clean, readable webpage. The code extracts the paragraph and list items from the XML, stripping out Word-specific markup, and displays them with basic HTML styling. It uses the browser’s built-in DOM parsing to traverse the XML, then applies simple CSS for typography and spacing. The visualization focuses on presenting the furniture product’s features—such as fabric options, decorative nailing, and wood stains—in a plain, unadorned format, making the original document’s text accessible outside its native editor.

Feb 11, 2014
Loading thumbnail…

Gist 8865235

A Django model method updates inventory records by deleting any stock counts with a timestamp at or after a given time, then inserting a new count for that item. The `set_stock_count` function filters `StockCount.objects` using `timestamp__gte`, removes matching entries, and creates a fresh record with the supplied stock level. This demonstrates a time-series upsert pattern for tracking product availability over time, though the code shows no visualization logic, only the data-management layer.

Feb 7, 2014
Loading thumbnail…

Gist 8784990

This visualization shows the distribution and relationships of 150 tickets from a CodeBase project, rendered as a force-directed graph. The code first fetches ticket data via the CodeBase API using the `codebase-python-api-client`, then writes it to a CSV file with `csv.DictWriter`. The visualization itself relies on `d3.forceSimulation` to position nodes and links, with ticket attributes likely mapped to visual properties such as node size or color. The data source is the project’s ticket tracker, and the rendering approach uses D3’s simulation engine to arrange the network.

Feb 3, 2014
Loading thumbnail…

Gist 8784016

This example shows how to extend Django’s admin interface with custom JavaScript files using the `django_admin_blocks` library. It registers a configuration object that defines a `script_blocks` list, specifying two client-side resources: `js/jQuery.cookies.js` and `js/cms_admin.js`. The code relies on the `django_admin_blocks.register()` API to inject these scripts into the admin’s HTML output. The data source is the explicit URL paths in the list, and the rendering approach is the library’s block-based script loading mechanism.

Feb 3, 2014
Loading thumbnail…

Gist 8537515

This example shows a booking management interface where users can search inventory items, view their availability segments over a date range, and add them to a current booking. The AngularJS app uses `$http` to fetch booking data from `/api/booking/` and stock item segments from `/api/stock_item/.../get_segments_for_period/`, displaying date ranges as day/month labels and enabling toggling of child tracked items. It also supports creating new bookings via POST to `/api/create-booking/` and saving changes through PUT requests.

Jan 21, 2014
Loading thumbnail…

Angular typeahead snippet.

Two AngularJS typeahead inputs demonstrate both synchronous and asynchronous autocomplete. The first filters a hardcoded array of U.S. state names using `$viewValue` and `limitTo:8`. The second uses `$http.get` to query the Google Maps Geocoding API, returning formatted addresses as a promise, with a loading glyphicon shown via `typeahead-loading`. Both bind selections to the model, displayed as JSON in `<pre>` blocks.

Jan 18, 2014
Loading thumbnail…

Gist 8479609

This example shows a Django REST Framework serializer that exposes booking data alongside a dynamic list of salesperson options. The `BookingSerializer` model serializer outputs fields for booking ID, booking number, current salesperson, and a custom `sales_people_options` field. The `UserOptionsField` uses the `field_to_native` method to query all users and return their IDs and usernames, providing a dropdown-style selection list in the API response. It relies on Django’s ORM and the `serializers.ModelSerializer` and `serializers.Field` classes from Django REST Framework.

Jan 17, 2014
Loading thumbnail…

Gist 8420680

This example demonstrates a simple text-input binding pattern, showing a hard-coded value on the left that changes to an AngularJS two-way bound model on the right. The code uses AngularJS’s `ng-model` directive to connect an input field directly to a property on the current booking object, while the left input uses a static template expression with `{{ }}` that displays the same value without updating it. The transition highlights how `ng-model` enables live synchronization between the view and the underlying data model, whereas the plain interpolation only renders the initial value. No external visualization libraries are used; the example focuses on AngularJS’s data-binding mechanics.

Jan 14, 2014
Loading thumbnail…

Gist 8401198

This example shows a Django management command that clears cached thumbnail data and removes the corresponding thumbnail files from storage. The code uses the sorl-thumbnail library’s default key-value store and storage backend to wipe the cache and delete the `_thumbs_` folder contents. It accepts a `delete` argument to trigger the cleanup, first calling `default.kvstore.clear()` to empty the cached entries, then iterating over items in the thumbnail storage directory and removing each with `rmtree`. The command prints status messages after each step.

Jan 13, 2014
Loading thumbnail…

You have failed me for the final time, brain.

A booking-management interface shows inventory availability as a horizontal timeline, where each stock item displays colored segments representing stock levels across the requested hire period, with unavailable days overlaid. Users can search inventory, adjust delivery and collection dates, and add items to a secured list with pricing details. The visualization is built with AngularJS controllers and factories, using `$resource` to fetch booking data from a REST API and `$http` to load per-item segment data from a stock-item endpoint.

Jan 11, 2014
Loading thumbnail…

Gist 8370783

This example shows a stock management interface where users can search for stock items and view their availability segments against a booking’s date range. An AngularJS controller watches the booking ID, fetches booking data via the `$resource` API, and computes a day-by-day range list. The `StockItems` factory uses `$http.get` to query the stock item search endpoint and then retrieves per-item segments for the current booking. The view displays these segments alongside the computed date labels, using AngularJS data binding to update the table dynamically.

Jan 11, 2014
Loading thumbnail…

Index

A single red rectangle is rendered on a transparent canvas using the Canvas 2D API, positioned near the center of the page. The shape is drawn with a solid red fill and a thin black stroke, as defined by the Google Web Designer serialization data embedded in the page. The code reads the serialized canvas configuration and directly invokes the 2D context methods `fillRect` and `strokeRect` to produce the static graphic, with no interactivity or animation.

Sep 30, 2013
Loading thumbnail…

Gist 5344001

This example presents a configuration file for a Django CMS development environment, not a visualization. It sets up local database connections, enables debugging tools like the Django Debug Toolbar and django_extensions, and configures media and static file paths. The code also includes settings for the django-compressor, devserver, filebrowser, and backup modules, with several options toggled for development. No data visualization libraries or rendering methods are present in this file.

Apr 9, 2013
Loading thumbnail…

a triplanar / procedural UV / world space UV shader for Unity, cobbled together bits from @QuickFingerz and @Farfarer

This shader demonstrates triplanar texturing, projecting three separate textures onto an object’s surface based on its world-space normal direction. It blends side, top, and bottom texture samples using a power-saturated normal projection, with side textures sampled from the X and Z axes and top/bottom textures from the Y axis. The Unity shader uses a surface shader with Lambert lighting, and it applies world position coordinates to compute UVs, scaling each texture independently. The result is seamless, stretch-free texturing for arbitrary geometry without relying on traditional UV mapping.

Feb 6, 2013
Loading thumbnail…

List of interesting Django dmin-related code and projects

A linked network of nodes maps projects and code snippets related to Django admin, sourced from a gist by andybak. The visualization uses D3’s `forceSimulation` to position the nodes, with each node labeled by its repository or file name. Connections between nodes are drawn as lines, indicating relationships or shared references. The code explicitly names the GitHub source for `django-adminbrowse` and includes the raw gist URL, though the graph layout itself is rendered entirely with D3’s force-directed algorithm and SVG elements.

Nov 6, 2012
Loading thumbnail…

Gist f43601b1f490d87ec6f8

This example shows a Python script that downloads a Google Spreadsheet as a CSV file and prints its rows. The code defines a `Spreadsheet` class and a `Client` class that handles authentication via Google’s ClientLogin API, using `urllib` and `urllib2` for HTTP requests and `re` for parsing the authentication token. It then fetches the spreadsheet’s contents through the Google Sheets export feed, specifying the format as CSV and a worksheet ID, and parses the result with the standard `csv` module. The script demonstrates a straightforward command-line workflow for accessing spreadsheet data programmatically.

Jan 25, 2012
Loading thumbnail…

Nav mixin

This example shows a Django mixin for generating hierarchical navigation menus from a model tree, rendering nested `<ul>` and `<li>` structures with links or selected/ancestor states. The code uses `django.core.urlresolvers.reverse` for URL generation, `django.contrib.admin.site` for admin integration, and `django.utils.safestring.mark_safe` for safe HTML output. It relies on MPTT model methods like `get_ancestors`, `get_children`, and `get_siblings` to traverse the tree, filtering by `active` and `show_in_navigation` fields. The output is a string of nested HTML tags, with the current page rendered as a `<span>` and ancestors highlighted with CSS classes.

Jul 15, 2011
Loading thumbnail…

A Python style question

This example shows a Django survey form built with the MultipleChoiceAnswerForm ModelForm and a custom MyRadioRenderer for answer widgets. The survey view processes POST requests by iterating over Section and MultipleChoiceQuestion objects, validating each form with a "Q{question.id}" prefix, and saving valid answers to the MultipleChoiceAnswer model with the respondent. Unfinished surveys render a survey.html template with section and question data, while completed surveys redirect to a message.html template. The code uses Django’s HiddenInput, RadioSelect, RequestContext, and render_to_response APIs.

Apr 27, 2011
Loading thumbnail…

How to whitelist other admin lookups with Django 1.2.5

This example demonstrates how to override Django 1.2.5’s admin lookup restrictions by subclassing `ModelAdmin` and redefining the `lookup_allowed` method. It shows a whitelist approach that permits specific query parameters—such as `related__pk` and `related__custom_field`—while delegating all other checks to the parent class’s `super().lookup_allowed`. The code explicitly references Django’s `ModelAdmin` API and the `lookup_allowed` signature change in version 1.2.5, which added a `value` parameter. It relies on the built-in `super()` call to preserve default behavior for unlisted keys, illustrating a practical customization for admin list filtering.

Feb 10, 2011