Demofruit is a love letter to the C64/Amiga/DOS graphics and music demoscene of the 1980s and 90s, built to run on the Fruit Jam. Six classic demoscene effects have been ported using Claude Opus 4.8 to run in Arduino on the RP2350-based Fruit Jam

• Starfield forward-warping star field with bouncing text
• Plasma palette cycled summed sine waves
• Chrome Sphere a dual-core raytraced renderer
• Valley Run wireframe terrain flyover is a nod to the vector-landscape demos
• Rotozoom - tiling bitmap texture tranforms with rotation and scaling and lens effect
• The Juggler - port of Eric Graham's 1987 Amiga Juggler raytracer — an animated character juggling three mirrored balls over a checkered floor

All of the demos (and the launcher screen) are accompanied by tracker MOD songs created by kqvc that playback using the PocketMod MOD player.

Parts

From Wikipedia, the free encyclopedia

The demoscene is an international computer art subculture focused on producing demos: self-contained, sometimes extremely small, computer programs that produce audiovisual presentations. The purpose of a demo is to show off programming, visual art, and musical skills. Demos and other demoscene productions (graphics, music, videos, games) are shared, voted on and released online at festivals known as demoparties.

The scene started with the home computer revolution of the early 1980s, and the subsequent advent of software cracking. Crackers altered the code of computer games to remove copy protection, claiming credit by adding introduction screens of their own ("cracktros"). They soon started competing for the best visual presentation of these additions. Through the making of intros and stand-alone demos, a new community eventually evolved, independent of the gaming and software sharing scenes.

Software Installation

Head here first to download the latest release UF2 of Demofruit for Fruit Jam.

Enter RP2350 bootloader mode

Entering the RP2350 bootloader is easy. Complete the following steps.

Before you start, make sure your Fruit Jam is plugged into USB port to your computer using a data/sync cable. Charge-only cables will not work!

Turn on the On/Off switch - check that you see the ON light on so you know the board is powered.

To enter the bootloader:

1. Press and hold the BOOT/BUTTON1 button down. Don't let go of it yet!
2. Press and release the Reset button. You should still have the BOOT/BUTTON1 button pressed while you do this.
3. Continue holding the BOOT/BUTTON1 button until you see the RP2350 drive appear.
   
4. You can now release but BOOT/BUTTON1 button.

Demofruit is written in Arduino, so if you want to customize it go ahead and use the information on the next couple of pages to install Arduino IDE and set it up for use with the Fruit Jam.

Texture Conversion

The Rotozoom demo tiles and spins a 128×128 pixel source image stored in texture.h as an RGB565 array.

 Image requirements:

• 128×128 pixels (power-of-two - the demo wraps with a fast bitwise mask, TEXTURE_MASK 0x7F, instead of division)
• 24-bit uncompressed BMP (Windows/DIB), no alpha, no RLE
• Bold, high-contrast content — thick shapes, chunky patterns, or a strong central subject. Concentric shapes, mandalas, chunky pixel art, or a bold face/logo all work well.

Music

Each demo (and the menu) has its own soundtrack, played as a ProTracker MOD file. MODs are the native music format of the demoscene: a small bank of digitized instrument samples plus pattern data describing which sample plays at what pitch on each channel.

Playback uses pocketmod, an MIT-licensed MOD player, which renders the music in real time on core 0. The audio path is:

pocketmod mixes stereo float samples → converted to 16-bit → sent to the TLV320DAC3100 codec over I2S (via the RP2350's PIO + DMA).

Songs live in the sketch as C headers, one per slot:

Each header contains a MOD_DATA byte array; the sketch wraps each in its own namespace so they don't collide. pocketmod supports up to 32 channels, so 6-channel, 8-channel, and wider MODs play fine (not just 4-channel) — though authentic 4-channel MODs are the period-correct choice and mix with the least CPU. If a song fails to load, the sketch logs the failure and simply runs silent rather than crashing.

Converting your own MOD files

A helper script, mod2header.py, converts any ProTracker .mod file into the header format the sketch expects. It does a straight byte-to-array conversion — it does not alter the music.

python3 mod2header.py yoursong.mod song_4.h

The second argument is optional; if omitted it writes yoursong.h. To change a demo's music, convert your MOD directly to the matching song_N.h , then recompile. To change the menu music, target song_0.h.

Where to find MODs

• The Mod Archive  filter by license and by file size (leaner tracks make smaller headers and faster compiles)
• Compose your own in a tracker such as MilkyTracker runs natively on macOS, Windows, and Linux

 Notes on file size and editing

The bulk of a MOD's size is its sample data, not its pattern/song length. To shrink a header:

• In a tracker, the biggest lever is downsampling the largest samples in the Sample Editor (roughly halves their size per octave of rate reduction);  trimming silence and tightening loops also helps.
• Shortening the order list (how many patterns play in sequence) plus deleting the now-unused patterns/samples reduces size only modestly, but is the right tool for fitting a track's *length* to a demo.

pocketmod loops a MOD automatically at its end, so a clean loop point often matters more than absolute length. Whatever you edit, listen to the loop seam (play to the end and let it wrap) before converting to a header.

If you want to customize the Demofruit or just have a look at the code, download the Project Bundle linked below.

How It Works

Each demo began as a standalone sketch and was merged into the sampler launcher. They are listed here in menu order, which is also roughly chronological by technique.

Because the each demo uses a slightly different display configuration, and the DVI HSTX library display object is constructed once at startup, Demofruit uses a reboot launcher. This is a similar technique multi-part Amiga demos used to chain-load segments.

On power-up or after pressing reset, no launch flag is set, so the sketch shows the menu. This includes a tumbling, 3D cube behind green text, with the cube tinted to the highlighted demo's signature color.

Menu navigation

• Button 3 = up
• Button 2 = down
• Button 1 = launch

Selecting a demo writes its ID plus a magic number into the RP2350's watchdog scratch registers (which survive a soft reboot) and triggers a watchdog reboot.

On the next boot the sketch sees the flag, immediately clears it, and constructs that demo's ideal display and runs it forever. Because the flag was cleared at demo start, pressing **Reset** returns you to the menu.

The NeoPixel strip reinforces the UI throughout: in the menu it glows the highlighted demo's signature color; inside a demo it shows the current setting (e.g. Valley Run lights *N* of 5 pixels for the speed preset, in the current wire color). Pixel order is top-to-bottom. A brief blink acknowledges "randomize"-type buttons that have no persistent state to display.

Starfield

The star field is one of the oldest tricks in the demo scene, and it works through a bit of faked perspective. Each star is really just a point with an X, Y, and Z position, where Z represents how far away it is. To draw a star, the code divides its X and Y by its Z: distant stars (large Z) get pulled in close to the center of the screen and drawn small, while near stars (small Z) spread out toward the edges and grow large. 

To create the sense of flying forward, every frame simply decreases each star's Z a little. As Z shrinks, that division makes the star rush outward and accelerate, and when it passes the viewer it gets recycled to a new random position far away. That single divide per star is the whole illusion of three-dimensional motion.

On the Fruit Jam this runs at full frame rate because the math is so simple, which leaves plenty of room for the bouncing chrome text layered on top. Rather than allocating memory for each letter, the code reads the font's pixel data directly from the Fruit Jam's flash and plots the glyphs over the moving field, letting them bob and scale independently. The result is the classic "warp speed plus scroller" opener that demos have used for decades.

Plasma

This effect comes from adding several sine waves together — one that varies across the screen horizontally, one vertically, one along the diagonal, and one radiating from a center point. Where those waves reinforce each other you get bright values; where they cancel, dark ones. Summed across every pixel, the overlapping ripples produce those signature organic, lava-lamp blobs. The demoscene's key insight was that you do not need to recompute all that trigonometry every frame. Instead you precompute the wave values into tables once, then animate purely by sliding color-lookup offsets through those tables, a cheap addition instead of expensive sine calls.

The Fruit Jam version keeps that period-authentic approach. It builds the wavetables at startup and, in its lightest mode, animates by rotating a 256-entry color palette rather than touching the image at all. 

The original Amiga and VGA effects leaned on hardware palette registers to do this for free; the Fruit Jam instead keeps an 8-bit index map and translates it through a software color lookup table into the 16-bit RGB565 values the display wants. 

That software palette pass is so fast on the RP2350 that the demo also offers a fuller mode where the wave map itself is recomputed every frame, letting the plasma physically writhe and drift rather than just cycle colors.

Chrome Sphere

This demo is a real raytracer, the same fundamental technique used to render photorealistic 3D images. For every pixel on the screen, it casts an imaginary ray out from the camera into the scene and asks what that ray hits. If it strikes the checkered floor, the code works out which check square it landed in and shades it accordingly. If it strikes the chrome sphere, the ray bounces, it reflects off the surface and continues on to see what the sphere would be mirroring, which is what gives the ball its shiny, reflective look. The code also traces a second ray from each floor point toward the light to decide whether that spot sits in the sphere's shadow. Raytracing was far too slow for real-time animation in the demoscene era, which is exactly why doing it live here is satisfying.

The Fruit Jam pulls this off by putting both of the RP2350's processor cores to work. The chip has two cores, and this demo hands half the image to each: they raytrace alternating rows of the frame simultaneously, roughly doubling the speed. To keep the frame rate smooth, the scene is traced at a reduced resolution and scaled up to fill the display. As you press the buttons to move the light and camera, the new values are shared between the cores so both stay in sync, and the whole reflective, shadowed scene re-renders continuously in real time.

Valley Run

Valley Run is a flat-shaded 3D fly through in the spirit of the vector landscape demos and games like Star Fox. The trench is a mesh of points laid out in a grid, scrolling toward you to create forward motion. Each of those 3D points is projected onto the 2D screen using the same perspective divide the star field uses: divide by distance so far parts of the trench converge toward a vanishing point. The walls are drawn as wireframe lines connecting the grid, and the fighter ship is built from a handful of triangular faces. Each face is "flat shaded," meaning the code calculates how directly it faces the light and fills the whole triangle with a single brightness, giving that crisp, faceted, low-poly look without the cost of smooth shading.

Because the geometry is simple, the Fruit Jam renders the whole scene on a single core with cycles to spare. The ship's motion is more than decoration: it's knee-like banking and side-to-side strafing are computed each frame, so it leans into its movement naturally. A subtle animation also runs along the trench walls so the corridor appears to breathe as it scrolls. The buttons let you change the wire color, step through five scroll speeds, and randomize the terrain's height and roughness on the fly.

Rotozoom

A "rotozoomer" takes a flat image and rotates and scales it in real time while tiling it infinitely across the screen, and it was a demoscene staple because it looks far more computationally expensive than it actually is. The trick is to work backwards. Instead of asking "where does each pixel of my image end up on screen," the code asks, for every screen pixel, "which pixel of the source image belongs here?" It walks across the screen stepping through the source image at an angle and scale determined by the current rotation and zoom. When the coordinates run off the edge of the 128x128 source, they simply wraparound, which is what tiles the pattern seamlessly. Crucially, this stepping is done with fixed-point math — numbers that use integer arithmetic to represent fractions — because integer operations were, and on a microcontroller still are, much faster than floating point for this kind of per-pixel work.

The Fruit Jam version tiles a 128x128 texture whose power-of-two size lets the wrap-around happen with a single fast bitwise mask instead of a division. Both processor cores share the work of filling the screen. On top of the spinning texture, a translucent "lens" bubble drifts around in a looping orbit, magnifying and blue-tinting whatever is beneath it by resampling those pixels through a spherical distortion, a little flourish that shows off how cheap the underlying sampling really is. You can cycle motion presets, toggle the lens, and randomize the zoom range with the buttons.

The Juggler

The Juggler is a piece of computer graphics history. In 1986, Eric Graham created a raytraced animation of a robot juggling three mirrored balls to showoff what the new Commodore Amiga could do, and it became one of the most famous demos of its era. The catch was that each frame took the Amiga's 7 MHz processor around an hour to raytrace, so Graham rendered the frames ahead of time and then played them back in sequence like a movie. This demo is a faithful port of Graham's original 1987 raytracer code, right down to how it bounces rays off the reflective spheres and the checkered floor, with its recursion depth capped so mirror-in-mirror reflections terminate cleanly.

Demofruit follows Graham's exact strategy of render-first, play-later, just way faster. When you launch the demo, both cores of the RP2350 raytrace 24 frames of a full juggling cycle and store them in the Fruit Jam's 8 MB of PSRAM — you can watch the image build in a "venetian blind" pattern as the two cores fill alternating rows, which takes about 20 seconds. Once all 24 frames are cached, the demo plays them back in a smooth loop, and the buttons let you change the playback speed or pause. A single frame that took Graham's Amiga roughly an hour now renders in about a second and a half. The juggling motion itself — a proper three-ball cascade, with the figure's knees bending and body shifting its weight — was recreated for this port, since the original animation data was never part of the published source code.