Thanks for sharing. I love little neat demos like this. Keep them alive in 2025! Raw ASM is so efficient and lean. It puts modern programming bloated "obfuscations" to shame.

Thanks!
I have added a Turbo-c version to that archive, with my TCTINY build utility/library for TurboC. With that, the C version of the same demo builds to only 144 Bytes, so it is possible to build small programs like that with a high level language. Here is the TC version:

1/* MAGIXFLY.C  - Tiny MSDOS 3d flying effect demo in 144 bytes.
2   (by orac81)
3	
4Simple demo of ultra-small compilation using TurboC 3.
5
6To compile: tctiny.bat tc3path magixfly
7ie: tctiny \m\tc3\bin magixfly
8
9   (needs MASM and exe2bin, or TASM)
10*/
11
12include "tctiny.c" 
13
14unsigned char far *pVdu;
15
16unsigned int frame;	/* Frame count */
17
18void main() 
19{
20    register unsigned int x;
21    unsigned int y;
22    unsigned int calcy;
23
24    IO_VIDEOMODE (0x13);	/* Set VGA video mode 13h 320x200x256 */
25    
26    do {
27      pVdu = (char far *) ((long) 0xa0000000L);
28      for (y=10; y<210; y++) {
29        calcy = ((2560/y) + frame) ;
30        for (x=320; x; x --) {
31          *pVdu = (BYTE) (((((x<<4)/y) ^ calcy) + (frame >> 8)) & 31) ;
32          pVdu ++;
33        }
34      }
35      frame ++;
36      IO_GETKEY (x);               /* See if ESC key hit */
37    } while (x == 0);
38}
39

Here is the TCTINY lib with some more such demos..

https://github.com/orac81/miniapples/ra ... ctiny.zip

Ha.. Of course, I don't include Turbo C in the list of those modern bloated obfuscations such as Java, Javascript, Rust, Python, etc, etc.

I posted this up on pouet, and of course someone comes along and rejigs the code, so it now compiles to just 52 Bytes! Without the exit check it would be about 48 bytes.
The end tests for loopX/loopY are really ingenious.

But I bet no one can improve on this.. 🙂

1; MAGIXFLY.ASM by orac81, improved by rrrola.
2; 52 byte flying demo.
3; es:di = pixel address, bx=time, bp=y, cx=x
4
5OFFSETY equ 12
6
7  org 100h
8
9  mov al,19
10  int 10h			 	; Screen mode 19 - VGA 320x200x256  (Using default VGA palette)
11  push 0A000h
12  pop es
13
14reloop:
15  mov bp,OFFSETY
16
17loopY:
18  inc bp
19  mov ax,0A00h
20  cwd  ; dx=0 (ax=2560)
21  div bp
22  add ax,bx
23  xchg ax,si
24
25  mov cx,320
26loopX:
27   imul ax,cx,16
28   cwd  ; dx=0 (ax<=5120)
29   div bp
30   xor ax,si
31   add al,bh
32   and al,31
33   stosb		; (es:di) = al
34  test di,di		
35  loopnz loopX		; X--; if (X) goto loopX;
36  jnz loopY		
37; di=0 after the loop
38
39  inc bx
40
41  mov ah,1
42  int 16h
43  je reloop
44
45  ret
46

Just for kicks I converted your demo to Bruce's C compiler and AS86 assembler from its package. It works! Files attached.
Somehow I even saved one more byte! 😀

MH: Thanks for that! Some of the early DOS C compilers were really efficient, and can be tweaked for small code by hacking the default libs. I was going to try Pacific C, and Whitesmiths C, which had a rep for speed:

https://github.com/hansake/Whitesmiths-C-compiler

I updated magixfly, (same link) making it 8086 compatible, now 54 bytes, also added CGA version.

Also added cgaplasma:
https://github.com/orac81/miniapples/raw/refs … ain/cgaplas.zip

this is cool, especially the ports between c compilers of the time, i'd bet it works well in masm or tasm too, directly or inline.

I like the explicit use of registers, it's the kind of thing that used to go on in z80 and other old 8 and 16 bit computer demo programming too

I used to love all these demos and so on back in the early internet when enthusiasts would do things in asm c, pascal and qb to see what is possible, how far systems could be pushed and so on

These demos inspired others and sometimes even led to games and game engine ideas

Traditionally, there were three categories of demos:
- full size
- 64 KB
- 4 KB

Later, there came the 256-Byte species.

Now, are we witnessing the birth of yet another category?

Have a look here, Grzibby. 😉

orac81 wrote on 2025-05-07, 12:16:

MH: Thanks for that! Some of the early DOS C compilers were really efficient

If you like earlier C compilers probably Sphinx C-- may also be interesting to you. It already has nice built-in graphics capabilities.