10 PRINT CHR$(205.5+RND(1)); : GOTO 10

100%

10 PRINT CHR$(205.5+RND(1)); : GOTO 10

✓ Published0🌍 Public

Last edited Jun 6, 2014

Created on Jun 6, 2014

This example visualizes the iconic Commodore BASIC one-liner "10 PRINT CHR$(205.5+RND(1)); : GOTO 10" by rendering a maze-like pattern of diagonal slashes and backslashes. It shows how a single line of code generates complex, emergent visual texture. The visualization uses a grid of characters, likely rendered via a canvas or SVG, where each cell randomly selects between the two slash characters using a pseudo-random function. The code leverages the browser’s Math.random() for the stochastic element, and the rendering approach mirrors the original program’s output, with no external data source beyond the algorithm itself.

AI-generated description

Similar vizzes

Loading thumbnail…

#10print

A circular grid of slash marks continuously regenerates inside a black, round SVG canvas, its patterns and opacity driven by 3D Simplex noise. Each cell's rotation flips between slash and backslash, while opacity varies with the noise value, producing an organic, flickering maze. The animation runs via `d3.interval`, updating per-cell values and applying transitions with `attrTween`-like direct attributes. It uses D3 v4, the `simplex-noise.js` library, and draws SVG paths for the line characters.

KKcnarf

70% match

Loading thumbnail…

Gist d740d28ab2549ada2394dbbe9728cd71

This visualization prints an alternating checkerboard pattern of spaces and hash symbols to the console, using standard JavaScript string concatenation and a nested `for` loop structure. The outer loop controls each row, while the inner loop builds the pattern by checking whether the row and column indices are even or odd. The code defines a fixed grid size of 8, generates each line into a string variable, and logs it with `console.log` before resetting the string for the next iteration. No external libraries are used; it relies solely on core JavaScript syntax and the console API.

MMistyBlunch

67% match

Loading thumbnail…

Random Traversal

A black canvas displays a maze being generated cell by cell via a random traversal algorithm. White cells mark the growing maze structure, while magenta highlights the current frontier of possible extensions. The animation progresses in steps, using the Canvas API to draw rectangles for cells and connections. The code implements the algorithm with a frontier array and popRandom selection, using d3.v3's timer for animation control.

Mmbostock

66% match

Loading thumbnail…

Maths functions, mostly from Processing.js

This example demonstrates a collection of mathematical visualization techniques implemented in JavaScript, primarily relying on custom pseudo-random number generation and Perlin noise algorithms. The code implements Marsaglia's random number generator and a full Perlin noise implementation with 1D, 2D, and 3D variants, which can be used to create organic, procedural textures and patterns. The visualization likely renders these noise functions as visual output, showcasing how deterministic noise algorithms can produce complex, natural-looking variations. The code is based on Processing.js conventions, with a Math2 class providing random and noise functions similar to those found in the Processing API, allowing for generative art and data-driven graphics.

MMAKIO135

65% match

Loading thumbnail…

Gist 119211

This example visualizes the Mandelbrot set as a fixed ASCII-art plot in a terminal, using Ruby’s `Complex` class to iterate the function `z*z + c` fifty times per point. The code samples a 2D grid over the complex plane—x from -2.0 to 0.5 and y from 1.0 to -1.0—and prints an asterisk when the final magnitude is less than 2, otherwise a space. It shows a symmetric, high-level fractal silhouette rendered entirely with text characters, with no graphical libraries involved. The rendering approach relies on nested `step` loops and `Array.new(50,a).inject` to perform the iteration, producing the classic bulb-and-spiral structure directly in the console output.

DDylanFM

64% match

Loading thumbnail…

Random Squares

Random Squares demonstrates SVG shape generation by populating a 1000×1000 canvas with 500 randomly positioned, sized, and colored rectangles. Each `<rect>` element receives a random RGB fill, a random x/y coordinate within the viewport, and a random width and height up to 50 pixels. The code uses vanilla JavaScript with `Math.random()` to compute values and `document.querySelector('svg').innerHTML` to append shapes directly to the SVG DOM. The result is a dense, chaotic mosaic of overlapping squares with no underlying data or interaction, showcasing basic SVG rendering through a simple procedural loop.

NNita

64% match

Loading thumbnail…

Random lines

This example shows a 1000 by 1000 pixel SVG canvas filled with five hundred random lines. The lines have randomly generated start and end coordinates, and each line is assigned a random hexadecimal color. The code creates the lines dynamically using the DOM API, specifically `document.createElementNS` with the SVG namespace, and appends them to the SVG element via `getElementsByTagName`. The rendering is pure SVG, with no external libraries or data sources.

NNita

63% match

Loading thumbnail…

Fork of Fork of HTML Starter

A simple HTML page demonstrates a canvas-based visualization using CSS and JavaScript. The code constructs a grid of colored squares whose positions and colors are computed from a seed value, creating a deterministic pattern. It uses the JavaScript `Math.random()` function to generate the layout, with the canvas rendering handled through the Canvas API's `fillRect` method. The page serves as a minimal example of combining HTML structure with procedural drawing logic.

BBALAJI MANDAVA

63% match