Analysis model: gpt-5.5 xhigh

Huge Crowd by NoooN and Orange - Technical Dissection

Huge Crowd is a December 1996 64K intro by NoooN and Orange, released at The Party 1996. Pouet lists it as an MS-DOS/GUS and Windows production, ranked sixth in the 64K competition. The original DOS archive identifies the authors as Barti, Dune, and Zeb at "Big-Bang University" and describes the effect set as "crowded zbuffered vectors."

This is not a many-part effects reel in the usual Orange 1996 sense. It is a single atmospheric object/world study: white hand-drawn title, a purple vortex, a rough asteroid/crowd mass, handwritten university text, and a later branch or stick-like foreground over the same turbulent field. The interesting technical shape is the compressed 64K carrier expanding into a PMODE/W DOS runtime with a Mode 13h presentation loop, timer/music-position scene gates, a full 64K framebuffer copy path, XMS allocation code, and visible remnants of a 1995 mapper/engine tool.

Sources

Pouet production page: https://www.pouet.net/prod.php?which=4982
Pouet Orange group page: https://www.pouet.net/groups.php?which=30
Original Scene.org DOS archive: https://files.scene.org/view/demos/groups/orange/h-crowd.zip
Scene.org Windows remake archive: https://files.scene.org/view/demos/groups/nooon/hcrowd2005.zip
Public video reference linked from Pouet: https://youtu.be/3PdYGFIcWXM

Pouet metadata:

title:          Huge Crowd
groups:         NoooN and Orange
type:           64k
platform:       Windows and MS-Dos/gus
release party:  The Party 1996
ranked:         6th
release date:   December 1996

The 2005 Windows archive was only used as a variant boundary. The analysis below is based on the original DOS archive and the public video reference.

Examined Files

Archive hashes:

c0dcab50ba7eba6c0cd686bf826afa68459cc602ad6436fca79baa79b5daa9e7  h-crowd.zip
82ef275cdf33c84aa1d02bdb0f6548f3ab9c914a567b75a02d0e51d6c2722069  hcrowd2005.zip

Original DOS archive:

ebf18ae9ed8c972af2e32a18e75d25c0a6a3734311e5ed5767cc2aafef83ba02  H-CROWD.EXE
a3339b89b36204a6437d9954a890de88860989832f51395836a874b93f386245  H-CROWD.TXT
78619c7a161df2ddc6b1a54df5e4414fb08a58435171cf3af8a1a1b8b3a3ebc2  FILE_ID.DIZ
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  ENTRY.#14

The DIZ names the production and party context:

Huge Crowd by NoooN-Orange

    Barti! - Dune - Zeb
  at Big-Bang University

        TP6 Intro

H-CROWD.TXT says it was dated December 24, 1996, made in two days, requires nearly 600 KB conventional memory and nearly 2 MB XMS, does not need EMM386 or QEMM, and calls the effect "crowded zbuffered vectors."

The Windows remake archive contains two 65,536-byte UPX-packed PE executables, Huge Crowd.Exe and Huge Crowd(24bits).Exe, plus a 2005 remake DIZ. Those files are not mixed into the DOS binary analysis.

Public Visual Evidence

The Pouet screenshot is a 320x200 GIF:

da141ea1809459d825190d787f99352afbff73a97146f8f7cf4cafb48510196c  pouet.gif

Huge Crowd Pouet screenshot GIF

The public video boundary:

sha256: b06a0fe771a9f118c614d2a19f0860cfeb654954cfab040e23a9c30b78299ec4
video:  h264, 1066x720, 60 fps
length: 181.85 seconds

The stills and GIFs below are direct full-frame downscales from the 1066x720 MP4. They are time slices only: no cropdetect, viewport correction, padding, browser screenshot, lightbox screenshot, or guessed DOSBox canvas size.

Huge Crowd public-video contact sheet

Opening Logo And Title

The intro starts with a black field and a small white hand-drawn Huge Crowd mark. The names Barti, Zeb, and Dune are placed around it like annotations rather than ordinary scroller credits.

Huge Crowd public-video title frame

That title treatment fits the later runtime strings: the executable still contains a compact font table and editor-style strings, so the hand-lettered look is not just an external video artifact. It is part of the design language: thin high-contrast text over a mostly black field before the vector/object mass arrives.

Vortex And Crowd Mass

The first moving section is the best short animation: a dark center opens into a purple-white vortex, then a brown mass grows and rotates in the middle. A still can show the color, but it cannot show the way the bright field curls around the center.

Huge Crowd public-video vortex motion clip

Huge Crowd public-video vortex still

The visual looks painterly, but the DOS text's "zbuffered vectors" wording and the code shape point at a compact object renderer being composited into a palette-driven framebuffer, not a pre-rendered video player. In the unpacked binary, the effect loop repeatedly writes a 64,000-byte frame into A000:0000 using 32-bit stosd:

0x02a2: mov    ax, 0xa000
0x02a5: mov    es, ax
0x02a7: xor    di, di
0x02a9: mov    ecx, 0x3e80
0x02b2: mov    eax, [esi]
0x02ba: add    esi, 4
0x02be: stosd
0x02c0: dec    ecx
0x02c2: jne    0x02b2

0x3e80 doublewords is exactly 64,000 bytes, the size of a 320x200 8-bit Mode 13h frame. Several nearly identical blocks exist at 0x07ab, 0x0878, 0x097a, 0x0aa2, and 0x0c25, which suggests separate scene handlers sharing the same backbuffer-to-VGA commit routine.

Text Over Field

The middle section overlays handwritten text over the turbulent object field:

Huge Crowd public-video Big-Bang University text frame

This is where the intro's "university" joke becomes visible. The line is not a conventional greets scroller; it behaves more like a title card composited over the same color turbulence. The code has a small transparent text/byte-stamp helper at 0x158b: it reads bytes through fs:(si), skips zero bytes, writes non-zero pixels into a destination pointer, then advances by 0x140 per row.

0x158b: add    edi, [0x50ad]
0x1590: mov    ax, 0x15eb
0x1593: mov    fs, ax
0x1599: mov    cx, bp
0x159b: mov    al, fs:[si]
0x159e: inc    si
0x159f: cmp    al, 0
0x15a1: je     0x15a6
0x15a3: mov    [edi], al
0x15a6: inc    edi
0x15a8: loop   0x159b
0x15ac: add    edi, 0x140

The 0x140 stride is 320 decimal. That makes this a screen-space row plotter: it preserves transparency by not writing zero bytes and steps one scanline at a time.

Branch And Foreground Pass

The later part adds dark stick/branch silhouettes over the same field. This clip is more useful than a still because the foreground pieces make the object feel like a depth cue rather than a flat texture.

Huge Crowd public-video branch foreground motion clip

Huge Crowd public-video branch foreground still

The branch pass is also the best visual match for the "crowded" wording: the screen is not showing a single clean mathematical object, but a busy pile of small projected pieces, filtered through a very soft palette.

Runtime-To-Code Concordance

The public video breaks into four visible jobs, and each has a matching runtime boundary in the unpacked DOS executable.

The black title and hand-drawn credits sit on the normal Mode 13h surface. The intro enters int 10h mode 13h, uses 320-byte screen strides, and has a transparent byte-stamp helper that can draw nonzero text/glyph pixels over an existing frame.
The purple vortex/crowd-mass GIF is the visible form of the TXT's "crowded zbuffered vectors" claim. The analysis does not recover a clean source-level object renderer, but the code does show repeated scene handlers copying a generated 64,000-byte backbuffer to A000:0000, which rules out a simple bitmap slideshow reading.
The Big-Bang University text card is not just typography pasted into the article. The 0x158b helper reads a byte stream through fs:(si), skips zeroes for transparency, writes nonzero pixels, and steps by 0x140 per row, matching a text/stamp overlay on the 320-wide framebuffer.
The branch foreground clip matches the intro's scene-gated structure: the timer/music-position hook advances 0x4f6f, and separate handlers keep committing complete frames while the foreground/object state changes.
The soft purple/white palette vocabulary has a code-side counterpart in the 0x300-byte table blend, while the final display is paced by the 3DAh retrace wait.

So the safe interpretation is: Huge Crowd is an object/mapper-driven 64K world study, not a multi-effect checklist and not a video player. The public clips show the object mass, handwritten overlays, and foreground crowding; the unpacked PMODE/W runtime explains how those generated 8-bit frames are timed, blended, stamped, and copied onto a DOS VGA screen.

Loader And Unpacked Runtime

The original H-CROWD.EXE is a 65,500-byte DOS MZ executable identified by file as Compack-compressed. The packed header is not a useful program map:

packed size:           65500 bytes
MZ header paragraphs:  0x0002
relocations:           0
CS:IP:                 0000:0000
SS:SP:                 3dbc:0800
minalloc/maxalloc:     0x565e / 0xffff
PMODE/W string:        present at raw 0x006e

Running UNP.EXE under DOSBox-X expands the file to a 252,928-byte MZ:

98cd61174ce0189cacfd5c11dee6e3ec979c251265ccf6ef8946632407378751  H-CROWD.EXE

The restored MZ is still a DOS extender executable, not a neat flat source listing. Its header is nevertheless much more useful:

unpacked size:         252928 bytes
MZ header paragraphs:  0x0007
relocations:           0x0014
CS:IP:                 0000:0045
SS:SP:                 56b9:fa00
minalloc/maxalloc:     0x28a0 / 0xffff
PMODE/W string:        present at raw 0x0070

The PMODE/W banner is explicit:

PMODE/W v1.22 DOS extender - Copyright 1994-1996, Daredevil and Tran.

The runtime also carries module-format probes:

8CHN
FLT8
OCTA
6CHN
M.K.
FLT4

That matches the MS-DOS/GUS metadata: this is not a silent pure framebuffer stub. It has a tracker/music path and scene progression tied to music position.

Startup, XMS, And Mode 13h

The original text's XMS requirement is mirrored in the executable. Near 0xfdca in the unpacked image are the memory failure strings:

memory control list is corrupted !...
memory allocation error !...
you must have a XMS driver installed...
not enough free extended memory for workspace...
all available extended memory handles are in use...
extended memory allocated unsuccessfully freed...
unable to lock extended memory allocated...
error gating A20...

The visual runtime enters 320x200 256-color mode near the start of the unpacked image:

0x0128: mov    ax, 0x0013
0x012b: int    0x10
0x0130: mov    dword [0x7300], 0x00000fa0

0x0fa0 is 4000 decimal, which is a useful row/block cadence in a 320x200 byte framebuffer. The code later uses 320-byte row strides for transparent stamps, so the screen model is consistently byte-indexed Mode 13h even though the renderer uses 32-bit registers heavily.

Scene And Timing Control

The main timing hook starts at 0x0ae6. It accumulates 0x11eb into a word at 0x4e92; on carry it advances two 32-bit counters and optionally calls a routine through a pointer-like value:

0x0aed: add    word [0x4e92], 0x11eb
0x0af3: jae    0x0b12
0x0af7: inc    dword [0x4f1d]
0x0afc: inc    dword [0x4f19]
0x0b01: cmp    byte [0x485d], 1
0x0b08: mov    esi, [0x83eb]
0x0b0d: call   0x166a

After that, the handler reads a value at cs:0x40ba and maps it to the scene state byte at 0x4f6f:

0x0b1e: cmp    word cs:[0x40ba], 0x02
0x0b24: je     set_scene_0
0x0b26: cmp    word cs:[0x40ba], 0x04
0x0b2c: je     set_scene_1
0x0b2e: cmp    word cs:[0x40ba], 0x06
0x0b34: je     set_scene_2
0x0b36: cmp    word cs:[0x40ba], 0x09
0x0b3c: je     set_scene_3

The concrete scene writes are visible a few bytes later:

0x0b8f: mov    byte [0x4f6f], 0
0x0b97: mov    byte [0x4f6f], 1
0x0b9e: mov    byte [0x4f6f], 2
0x0ba5: mov    byte [0x4f6f], 3
0x0bac: mov    byte [0x4f6f], 4
0x0bc8: mov    byte [0x4f6f], 5
0x0bdf: mov    byte [0x4f6f], 6
0x0c12: mov    byte [0x4f6f], 8

The frame handlers test the same byte. For example, the scene-2 loop exits only while 0x4f6f is still 2; otherwise it jumps back into the previous handler region:

0x08b2: cmp    byte [0x4f6f], 2
0x08b7: jne    0x081b
0x08bb: ret

This explains the public video's structure. It is not a free-running random camera; it is a small set of long-running visual states selected by a timer/music-position value.

Retrace And Palette/Hardware Output

The VGA retrace wait is compact and conventional:

0x1582: mov    dx, 0x03da
0x1585: in     al, dx
0x1586: and    al, 0x08
0x1588: je     0x1585
0x158a: ret

There are hundreds of out dx, al sites in the unpacked image. One local cluster around 0x35f0 writes to a base port derived from 0x409a plus small offsets, including values 0, 3, and 0x0d. Without the full device context it is not safe to name every port, but the structure is clear: scene state and per-channel values feed hardware register writes, while the final screen presentation is retrace-paced.

The palette crossfade / table blend shape is visible around 0x0440. It reads table words, scales differences, and writes a 0x300-byte RGB-style table:

0x046f: mov    di, 0x7908
0x0472: mov    cx, 0x0300
0x0475: mov    al, [si+0x7308]
0x0479: sub    al, [si+0x7608]
0x0480: imul   bx
0x0482: sar    ax, 6
0x0485: add    al, [si+0x7608]
0x048a: stosb

0x300 bytes is exactly 256 RGB triples. This is the code-side counterpart to the public video's soft purple/white fade vocabulary.

Mapper/Engine Remnants

The unpacked image contains a conspicuous tool string:

- LAURENT CANCE OLD ENGINE 95 -- MAPPER -------------
INFORMATIONS:
AZ RX:         UI TX:          F1,F2 CHG DE POINT
ER RY:         OP TY:          CLIKER SOURIS
TY RZ:         P. TZ:          S:SAVE

This looks like an embedded development mapper or old object-tool overlay, not a message intended for the released intro. Its presence matters because it explains the production style: the show feels like a camera/object study around one mapped mass, and the binary still contains editor vocabulary for rotation, translation, point changes, mouse clicking, and saving.

The executable title string is nearby:

HUGE-CROWD by NOOON-ORANGE  (c) 1996.
Enter gus baseport : [ 2x0h ]

The GUS base-port prompt is another reminder that the party version is a DOS hardware intro. The later Windows remake is a useful viewing fallback, but it is not the runtime analyzed here.

Why It Matters

Huge Crowd sits at an odd point in the Orange/NoooN overlap. It is later than The UFO Project, close in time to Orange's Deesbab and Megablast, but it does not chase the same collage-heavy demo structure. It narrows the design to one small world and makes the motion, palette, and object density carry the whole intro.

The code supports that reading:

a Compack 64K carrier expands to a much larger PMODE/W runtime;
the visible path is still ordinary Mode 13h at the output boundary;
a 64K backbuffer is copied to A000: in repeated scene handlers;
a timer/music-position gate selects scene state through 0x4f6f;
a 320-byte-stride transparent plotter handles text/stamp overlays;
palette table blending matches the soft public-video color transitions;
XMS/A20 strings match the original memory requirements;
mapper/editor strings explain the object-study feel better than the public screenshot alone.

The result is a compact 1996 intro that looks more like a living sketchbook than a conventional effect checklist.