awards discontinued, hence the demoscene must be dying... right?

Once the news was out that the Awards would not happen again (after 10! years!), people started creating threads in forums and concluding that the demoscene was evidently dying, had been dying for years already, or had already died a while ago. Choose your favourite option if you might, but you won't find me agreeing with any of those.

I don't think the awards are being discontinued because the demoscene is dying, but because they organisers might have other priorities in life nowadays, and the awards were really time consuming. I was part of the jury once, and I can attest that it was hard work. So imagine doing that for 10 years and coordinating many sceners from different backgrounds and idiosyncrasies! I think they deserve a big farewell thank you, as the Awards provided for much excitement, a certain amount of glamour, and many easy playlists for when we wanted to recommend "the best of the demoscene" to people who didn't usually watch demos.

Which brings us to the demoscene death topic. Is it true? Is it dead or about to be? Does anybody still watch demos? For me, the demoscene is well alive and kicking, albeit maybe not in the shape die-hard demosceners are used to, and it's going to kick a few butts in the future, once the transition to the web is completed.

The transition to the web? What? Am I insane? No, I am not, though I've been branded like that by those die-hard demosceners. Abandon their C or their C++ compilers! Or heaven forbid... their ASSEMBLER! And use JavaScript which is not a real language and does not give you all the control you deserve! Was I really serious? Of course I was. Because if the demoscene wants to survive in any way, it needs to go with the flow and get online, just like the rest of popular stuff is doing.

Back in the days, demos were the memes that techies exchanged between them. You got some nice intro and you shared that with your friends, in copyparties, BBSs or even sending them floppy disks by post. When the Internet got popular around 1995-ish, people started using it for distributing their demoscene productions, and it worked well until "the public" stopped being the tech-savvy sort of people that had been until then, and mutated into "people interested in audiovisual experiences, but not necessarily tech-savvy and not necessarily using Windows or willing to download and execute your production either". For all they knew, you could well be sending them a virus. And they hadn't actually installed or downloaded an application in years.

And this is where the web comes to the rescue. We have been going through a transition phase where the die-hard democoders kept working on their Windows code and tried to convince everybody that this was the real demoscene, and browser stuff was for people who couldn't have a look at Visual Studio without running away, screaming in pain. During this phase, most of the demos and intros were actually watched on YouTube because no one other than the programmer of the production could execute it. Be it because he had the most awesome graphic card ever while we were happy with an integrated card, or because no one had the exact Windows MFC-whatever DLL version, or because we hadn't used a Windows machine for years, or because the demo was for Mac OS latest version and wasn't compatible with Mac OS latest version minus 1 because XCode included a requirement for some obscure framework because of an even more obscure reason. Whatever the reason, the point is that watching something in YouTube doesn't lend it much credibility: it could have been rendered with After Effects, so what? The demoscene failed to impress.

But now this transition is coming to an end, and the web is here to replace that early mess. The future prospectives look oh so shiny and bright, for everybody: demomakers and demowatchers. With Canvas being "fast enough", and WebGL being increasingly available in more machines every day, and the proposed Web Audio API taking shape as a pretty decent audio platform, as well as the increasingly faster JavaScript engines powering nowadays' browsers, there's really no excuse to release native demoscene productions anymore--at least for current machines!

Before, you could just upload your demo to your humble webspace, link it from pouet or any other niche forum and hope that it was downloaded and executed by someone. Or maybe it had to be uploaded to (and good luck getting a file updated, due to the very nature of's FTP policies). Maybe you showed the demo in your local party, and got tapped in the shoulder by a few fellas: Hey hey, cool demo, will you pass me the beer? Kthxbye.

In short: your audience was extremely limited.

Now you just have to make your web-demo and put it in your website: the entire Internet can be your audience now. You don't believe me? Put some analytics in your index.html! See? It wasn't that easy with native apps. Also, did you improve something shortly after releasing the demo? Then simply update your online code. The next visitor will get an improved version! Good luck convincing everyone who got the first version of a native demo to download a patched "final" version.

For watchers, it's all excellent news too. Watching videos in Full HD in YouTube was sort of OK (apart from the mandatory "anybody know the name of the track?" comment), but nothing can beat the crispiness and the excitement of stuff happening in your computer, right now. Plus it takes less to download, usually, than a Full HD video. You also don't have to worry about managing downloaded files, and about virus either (well--unless it was a Java demo, hah!).

But we shouldn't stop here. That would be a very limited view of the demoscene in the 21st century. Casually, I read a post by Rafael Rozendaal on the browser as a canvas that totally relates to this topic. Basically, the demoscene has been using computers as a passive consumption device; there were hardly any interactive pieces. That's a recipe for disaster if we want the demoscene to stay current; people are used to interact with screens nowadays. Remember how we made fun of the then-omnipresent Flash intros? "I just skipped the intro!"

Transmuting the demoscene into the webdemoscene but maintaining the same old habits will just lead to people making fun of it as "that non interactive thing that stays with a black screen and a progress bar in the middle while playing cheesy music... then it started showing images of a castle or something but it wouldn't respond to the mouse so I just closed it because I got bored lol!".

I don't have the magic answer to how we are going to respond to this, but evidently the demoscene won't survive if it tries to perpetuate its old habits in new generations of people who have grown up with touch screens. There have already been some attempts like the Wilderness Downtown and RO.ME which, while not being purely demosceneish, are good proofs of concept of the things we can expect in the future, and do also act as an inspiration for younger aspiring demosceners.

And there's where we want to be: having more demos made by more new people with lots of crazy, fresh ideas. People who challenge the traditional demoscene conventions and surprise us with new stuff. And the great advantage of having the web both as distribution and consumption channel is that we can right-click on something that we like, and view the source in most of the cases. This not only taught us how to build terribly counterintuitive DHTML menus back in 1999, but will also allow curious kids to see how a demo is made, and try and improve it, or just make it do the total opposite of what it was doing.

More ideas that come to mind: a collaborative demo. Someone puts the initial code in github, and everybody else starts forking it and creating versions of it. Something like GLSL sandbox but with a demo. It could be terribly funny (or scary). Who's the author of the demo then? The concept of groups and creators gets diffused. Demos that interact with other browsers running demos (WebRTC). Demos that grab your face in the webcam and show it later in the demo--maybe replace your face with somebody else's face but keep your hairdo? Demos that can be rearranged in the order you like, and then shared and remixed with more people. Even the score could be modified and then generated, realtime, using the Web Audio API. Demos that change according to your location and the weather. Demos that start playing in your laptop browser and get complemented with things happening in your phone browser! Demos! Demos! More demos!

All this openness can be somewhat heretical to oldschool people. Letting someone else look at your code and learn about your secrets! What is this, communism!?! But that's just silly. If somebody really wanted to look at your code before, they could, by using a disassembler. Not that encrypting software has helped anyone hide anything to date, as copy-protection systems have demonstrated so far.

So I don't know about you, but I find these times incredibly exciting. For years I was getting increasingly frustrated with the demoscene, and having to lose time worrying about platforms while the only thing that I wanted was to make demos and have them watched. Finally we've got an incredible toolset available in our browsers, and to demonstrate, here's a table comparing native democoding versus web democoding:

Native Web
Initialising graphics systems Many lines of code, or having to include a multiplatform library such as GLUT or SDL Built-in ```javascript var canvas = document.createElement('canvas'); var context = canvas.getContext('2d'); // Or 'webgl' ```
Playing a song Using an external library such as FMod or BASS Built-in```html
Displaying text Many lines of native non-portable code, or having to include a multiplatform library such as freetype Built-in ```html

Oh hai

Displaying text with custom typeface Same than above Built-in ```css @font-face { font-family: customFont; src: url('customFont.ttf'); }

p { font-family: 'customFont', sans; }

Loading XML/JSON (for config files)
<td>Using external libraries such as TinyXML</td>
var xml = ( new DOMParser() ).parseFromString( xml_text, "application/xml" );
var json = JSON.parse( json_text );
Loading external bitmaps Using native libraries (non compatible between platforms) or external libraries such as libjpeg Built-in ```html ```
Using and compiling shaders Using GLEW or similar library Built-in ```javascript var gl = canvas.getContext('webgl');

// fragmentShader and vertexShader contain the shaders' code

var shaderProgram = gl.createProgram(); gl.attachShader(shaderProgram, vertexShader); gl.attachShader(shaderProgram, fragmentShader); gl.linkProgram(shaderProgram);


And those are just a few examples of things I've had to deal with when making demos for native platforms.

What are you waiting for? Please make demos for the browser! Make things like <a href="">this</a> and make people open their browser consoles' <em>Network</em> tab in awe and disbelief to ensure you're not streaming HD video (but please get rid of the preloading while you're at it, thank you!). Or maybe --excuse the shameless plug-- make like <em>me</em> and convert <a href="">a traditional demo</a> into <a href="">an interactive one</a>.

And if you're interested in making demos for the browser but miss the thrill of competing and watching them together with your demomates, <strong>more and more parties are including browser compos as first-class citizens</strong> (i.e. not thrown together with the rest of weirdos in the wild compo). If you're going to Revision, there's a <a href="">browser compo</a> hosted by none other than the brilliant web-demomaker <a href="">Gasman</a>. There's also <em>the</em> browser demoparty, <a href="">DemoJS</a>, and if what you want is to compete but prefer to avoid seating amongst people who shout <em>AMIGAAAAA</em> every two minutes, the somewhat regularly held <a href="">JS1K</a> compo might be what you're looking for.

There are many issues to be discussed in this "new" demoscene that I eagerly foresee, such as whether we're losing the "storytelling" in these interactive demos, in contrast with traditional demos where the narrative and the script are set in the code... although the "argument" of most of these demos might consist in <em>particles, particles, particles, tunnel, tunnel, explosion, particles, credits</em>. Or whether this is really demomaking or just <em>something else</em>, but I think it's better to address these by <em>doing</em> rather than by <em>talking</em>.

Still, if I may add something else, for me <strong>the demoscene is about pushing a platform to the limit and using computers creatively for fun</strong>, and that's exactly what we are doing, or what I'd like us to be doing.

<small>PS Please somebody make one of those <strong></strong> domains with a big <em>NO</em> in the body. Thanks!</small>