|
|
|
|
|
|
Quarterrific Assemblessings |
|
|
Four programs
I believe it was about five years ago, when a friend of mine came by with a floppy disk and an enthousiastic look on his face. "Do you know what demos are?" he asked me. I had many demo versions of games already installed on my computer so I found this to be a bit of an odd question. "No, no, no" he told me, "I'm talking about a different kind of demos - let me show you". On the disc he brought, there were four executables; each one was 256 bytes or less in size. The first one he started was called MIDNIGHT.COM and in a matter of seconds I was totally dumbstruck. I would never forget the first time I saw that demo.
Atomic Plasma by Luks
The things displayed on screen were simply mind boggling compared to the size of the executable. 3D spheres, animation.. how on earth was this even possible? I had dabbled with programming already (mostly in Turbo Pascal) and I believed that no application could be smaller than one kilobyte in size. What was going on here? Was there some way to fool the operating system into believing the program was smaller than it actually was? Or more importantly; who had created this and why?
Wormy by Khamoon
Small is beautiful
I realize that this article will most likely be read by oldskoolers, without a doubt more well-versed in this subject than myself, so I'll keep this section short.
The demoscene is about creating digital works of art. A good demo, diskmag or musicdisk should be beautiful and interesting at the same time. Technical quality is on the top of the list of important things to remember about demoscene productions. Since they are executable programs (and not pre-rendered animations or movies) there are many factors that count in a good production: good effects, lack of bugs, good hardware support, size and how the programmer uses advanced technical knowledge to create these dazzling pieces of digital art.
While regular demos (executable programs that have no real space limit) are cool indeed, my particular fancy falls with a specific type of demos called "intros". With an intro, the programmers need to bring another factor into the equation: file size. There are 64 Kilobyte intros, 4 Kilobyte intros, and as you have already read, 256 byte intros. Impressive feats indeed, but can you even begin to imagine what lies ahead?
Round numbers
Size limited demos, or intros, are very popular, and they also happen to be my favourite kind of demoscene productions. You will notice that I am only talking about PC intros here, but in fact there are intros for almost any other concievable platform, such as Amiga, C64, Atari and more.
Most intros fit into one of these categories: 64kb, 4kb and 256 bytes. There are other categories too, but these are the most popular ones. So what is the point you may ask? Well, it's mostly about good old-fashioned demoscene bragging. By creating such tiny programs, the authors show off their skills and impress other demosceners. "Hey man, see what I can do in one quarter of a kilobyte -- a standard Windows icon is three times bigger than what you see here!"
Fireworks
DOS makes it possible
Your average 256 byte intro is a DOS program in the COM file format, and is 256 bytes in size or even smaller. Compared to general executables for DOS and Windows that are stored in the EXE format, COM files are computer programs in their absolute form. Pure code and data, no headers, that occupy just one segment in the DOS memory. Windows compatible EXE files are simply too big and no packers will be able to bring the filesize down to that of a DOS COM file.
To achieve this very small file size, 256 byte intros are written in Assembler - a low-level language where each instruction is equivalent to a single processor command. The most popular Assembler compilers are Netwide Assembler (NASM), Flat Assembler (FASM) and Turbo Assembler (TASM). Compilers associated with high-level languages such as Pascal or C++ generate larger code and are therefore not used for tiny intros. There are exceptions of course; y0bi from wAMMA coded a 256 byte intro in C. He took advantage of an old Borland compiler with non-standard parameters and did it mainly to prove that it could be done. "The demoscene way", one might say.
But," you say, "nobody uses DOS anymore. Can't I watch these intros under Windows?" Yes, you can. Windows XP, as well as previous Windows versions, are equipped with a virtual machine that runs DOS programs. There are exceptions here as well, since some 256 byte intros use some dirty programming tricks to run. These intros will run fine in a pure DOS environment, which luckily can also be emulated using programs such as DOSBox. The downside of DOSBox is that it requires a reasonably fast computer to give you a decent framerate when watching demos, so if you happen to have a Windows 98 partition or a Windows 98 boot CD lying around, use it.
There are also some 256 byte intros coded in JavaScript and Flash, but these are considered to be in a separate class of demomaking and cannot really be compared to the DOS 256 byte category. There are some goodies here too though. Check out Metaballs by p01 if you get a chance.
Seaweeds by Grenhald / ALLien Senses
Mathemagic
Most 256 byte intros display impressive animations (at least for their size) in a graphics mode called 13h, which has a resolution of 320x200 pixels. It doesn't really sound that much when you compare it to typical Windows desktop resolutions of 1280x1024 and such, but using mode 13h is simply the most efficient and practical way of coding 256 byte intros. It's very fast, and since it is a standard mode, almost any PC is able to use it.
Just to cover the technical side of things: if a programmer wants to enable mode 13h, he has to call BIOS function 00h with argument 13h. After that, memory segment 0A000h can be adressed to put pixels onto the screen. There are only 256 colors available in this mode, but luckily the palette can be set in simple loops with various values. 6 bits are available for each RGB channel, so any intro utilizing this mode can utilize all kinds of original colors, gray scales or color gradients. But enough with the technicalities; the goal of this article is not to educate a new generation of demoscene programmers -- others are better suited for that.
With regard to effects in 256 byte intros, various 2d effects are usually employed, but these days also 3d effects have become common. There are intros that display a variety of different effects, such as tunnels, particles, fractals, attractor grids, scrollers, landscapes, rotozoomers, plasma effects, blobs, simple generated 3d shapes or any combination of the above.
In addition to regular demo effects, there are also some 256 byte intros that feature textmode effects, and even clones of such popular games as Tetris, Breakout, Snake, Space Invaders and Tron. There are some unusual approaches to 256 byte programming as well. One example is where the demos run as a TSR (Terminate and Stay Resident), and Advanced Raytracing where large images are generated from the names of empty files. Static images are also common, for example in the productions FireFrac by xb or Maelstrom by Dworkin. SELF-DISASSEMBLER by RiXtA puts another spin on the tiny demo style and lists its own source code as a part of the demo.
You can also find interactive works in 256 byte intros. Wolf by Kahmoon and 3D Wolfenstein Mouse Controlled by Pokeposer show amazing interactive 3D environments, inspired by the classic game. Some 256 byte intros even feature music: J256 by Rasky, Darth Scroller by Lord Kelvin and Collideum by Gekko all feature some kind of music playback.
If you wanted to look below 256 bytes, there are even smaller intros out there. 128 bytes, 64 bytes and even 32 bytes intros have been spotted. When you get below 65 bytes, the ability to press the Escape-key to quit the demo is usually removed to save space, and this is considered acceptable behaviour by most. How low can you go? Well, if you want to use a grahical mode (mode 13h) you will need 9 bytes. The guys from Farbrausch have even released an intro that uses text mode and clocks in at only 5 bytes.
BLIP by y0bi / wAMMA
Patience is a virtue
Creating works of art confined in small spaces is not easy. To start off you will need very good Assembler skills and a passion for math. I would generally recommend knowing your way around both things for any demo programmer, but it really is of good use when doing 256b intros. In addition to math and programming skills you will need heaps of patience. When you attempt at fitting normal demo material into such a small file, you will need to do a lot of re-thinking. Optimizing generally takes much longer than the initial coding, for example with eccentricity from Assembler Bot. "The coding took around 5 hours, but I spent another 40 hours optimizing and squeezing the code".
I have a feeling that the hard work behind many 256b intros is underappreciated. While demos, 64k intros and 4k intros is prone to huge appraisal at demo parties, the 256b seems to be seen as a curiosity and not as a "true genre" of demos. For example; there are no real 256b charts anywhere, if you disregard the possibility to search for them at Pouet.net. It really annoys me that "one-hour joke-prods" usually get a bigger and better response than a solid 256b intro.
Single player mode
Terapi by Anesthetic / Resident
Due to the somewhat obscure discipline that is 256b intro creation, almost all of them are created by individuals and not by groups, which is the norm for demos and 64k intros. Some of these individuals show themselves to be a bit ahead of the pack, and in my opinion the best 256b coders around today are baze / 3SC, Khamoon / Tube27 and y0bi / wAMMA. Of course, these are just my personal favourites, but there are many other great talents such as MZ1453, Serzh, silique, Assembler Bot, Alvaro, shr, Grenhald, Insomniac, Digimind, Galen, Optimus, dement, Fefe, Stephen and Ile. If you haven't yet discovered the joy of 256b intros, you should check out the productions of some of these people.
Earlier I believed that working on a 256b demo in a group would be pointless and inefficient. "100 Assembler commands and one brain -- sounds like a perfect match" I used to think. I was wrong of course. In January of 2007, a great programmer named Tigrou asked me for help with his new intro. A few days later he joined me, and I was no longer in a one-man-group. We finished our first project together. Even though we were thousands of kilometers apart it was a fantastic and truly unforgettable experience -- full nights of coding, talking over the internet, serious byte-crushing sessions and finally KOBRA was released.
3D Wolfenstein Mouse Controlled by Pokeposer / MovAX
Terminus
I remember the first 256b intros I saw like it was yesterday. Midnight Resistance. Optimized. AQUANAUTiCAL. Beziesux. They were just four tiny executables, but they changed my life for sure. Now there are around 700 productions in the 256b category, and you would just need a fraction of the space of a single floppy disk to fit all of them on there. Amazing thought, isn't it?
So where does one go to find all of these small pieces of art? Pouet.net and 256b.com are obvious choices, but as of today, only Intro Inferno (www.intro-inferno.com) seems to have a near-complete archive. You can also visit HardCode (hardcode.untergrund.net) where I have created a ZIP archive with most known 256b intros already packed and ready for watching.
In the year of 2007 where powerful processors and 500 GB harddrives are common, there are still some crazy people out there trying to reorder bits on the lowest level while still making complete computer programs in a fraction of the normal size. With Windows Vista, the future of 256b intros on PC seems a little shaky, but with new releases popping up for both the Atari and the C64 I have no doubt in my mind that I will continue to enjoy new (and tiny) masterpieces for a long time to come.
Go back to articlelist |
|
|
|
