Hacker News new | past | comments | ask | show | jobs | submit login
Farbrausch (demoscene group) releases their tools and engine (github.com)
270 points by ginsweater on Apr 15, 2012 | hide | past | web | favorite | 66 comments

Most people who were a part of the scene in 2000 remember The Product (1). I remember it winning The Party and being struck by how impressive their work was. If you're on windows, I guess you can download the demo itself (2). At 64kb, it should be a pretty quick download ;-) Their impressiveness has only gone up since 2000, as you can see by watching Debris (3), which at 177kb beats the living crap out of most things you see today.

The amount of work that goes into the tools these guys make is incredible. Quite happy to see ryg, kb and team release all this stuff. There should be a ton of things worthy of checking out in all this source code.

  [1] http://www.youtube.com/watch?v=LkEsP9H2HGM
  [2] ftp://ftp.scene.org/pub/demos/groups/farb-rausch/fr08_final.zip
  [3] http://www.youtube.com/watch?v=_efKXc4zd6w

I imagined that demo skills would eventually die and the more recent stuff would just end up being bloated or lame. But it really has improved. Infeasibly improved. Debris is amazing. But it isn't the only more recent amazing demo. Someone once asked me whether there was a limit to how realistic demos can be made. I would normally prate on about Shannon information or something, but it was a very smart mathematician who asked me. I did eventually think of a reason though. A demo is never going to contain a model of a piece of paper on which its own source code (plus additional information) is written in the demo. So there have to be some limits. But the limits don't seems to have been reached yet, especially with better and better modelling in the hardware.

Dan Piponi (a.k.a. SIGFPE)[0] wrote a shader[1] that paints its own source code.

I don't think he published the code, because it was written for Renderman shaders at ILM, though.

His blog is a must read if you're mathematically inclined.

[0] http://blog.sigfpe.com/

[1] http://homepage.mac.com/sigfpe/SRTX2008.pdf

Your piece of paper example caught me a bit off guard. It sounds pretty similar to a quine ( http://en.wikipedia.org/wiki/Quine_(computing) ). I think that the same thing is possible with a demo - write the code to render a piece of paper from an array of letters, and put that part of the source code into the array.

Yeah I'm wrong. What I had in mind I guess, is take an existing very impressive 64kb demo, then do this. That might be much harder, but not necessarily impossible in theory.

A far better argument for me to have made is that it would be impossible to have a 64kb demo which models a surface on which is printed the source code of all 64kb demos written since the start of the scene decades ago. Of course, if equations that describe all of reality are discovered and fit in 64kb, and the graphics card contains a universe simulator, then maybe it's possible.

Such a demo would be possible, it would just take an infinite time to run.

Self-introspective code is trivial, and it's been done before. I suggest looking at LISP :)

This is precisely the same thing as a quine. A Lisp program able to "introspect" its own source contains somewhere in the binary a quoted representation of the source code in some format (stored as a list instead of a string if we aren't worried about whitespace, comments and line breaks). Of course, with Lisp, you essentially bundle the compiler or interpreter with the binary. At any rate, the first known quine was apparently written in a derivative of ALGOL, not LISP.

Why not?

Fantastic tiny demos are truly the closest thing I've seen to magic. You know it's really a bag of tricks but it's simply so good.

I've always had a great deal of admiration for these kind of works. They elevate programming to an art form.

It's amazing how they can fit that much detailed demo in 64kb along with sound. Feels magical :)

Prepare to be amazed by 4k, Elevated by RGBA and TBC: https://www.youtube.com/watch?v=_YWMGuh15nE

Or the 4k remake of Chaos Theory: http://www.youtube.com/watch?v=WFAIaclLrKE. Elevated is a classic and a complete aesthetic package, but it's still a one-effect intro. Chaos Theory 4k is more varied but unfortunately it has a shitty synth.

Every time I see the this demo YT I want to teach myself C++ (despite I hate compiled languages) - this is great inspiration for me.

Nowa days this graphics is not really that impressive but back in 2000 that was jaw-breaking OMG

I guess, you'll have to learn so much more then just C++, most likely assembler too, and a lot (lot lot lot) of tricks. Everytime i see those multi-minute long demos, with music and animations and see those in 64k (or even 4k intros!!) i'm baffled.

In fact, you don't have to learn C++ either.

You can use any native compiled language without problems (say, Pascal). You can also use any other language as long as its runtime is small enough.

Most important though, much more so than whether you know C++, is knowing graphics programming. In fact, I've been calling myself a democoder for 10 years now, and I still suck at graphics programming, which is why my demos suck. Focus on the graphics, not the language. A fondness for math is much more important than a fondness for compilers.

I'd recommend making a demo in your favourite programming language. Don't care about size, care about looks. Once you've learned to make it good, you can consider learning, say, C(++) to make it small enough for the 64k or 4k categories.

Sidenote: most 4ks these days are entirely coded in a shader. This means you can mostly copy&paste the entire C part from somewhere, and start hacking GLSL or HLSL. Sure, you'd need to learn the shader language, but it's smaller and simpler than c++.

Actually in the PC Demoscene, many demos were done in Turbo Pascal with lots of inline assembly as well.

We were talking about now, not 20 years ago.

Now there is no longer a proper Demoscene.

In the old days a 64KB demo was really that. Now it is 64KB + several MB OS.

asm is not required anymore (besides reading it for debugging or optimization purposes)

you'd rather have to learn practical 3d/2d math and try many things out.

There are many other compiled languages besides C++.

Here is a small list of languages with known native compiler implementations, that you could eventually use:

- Pascal (Actually all implementation have some extended form) - Modula-2 - Modula-3 - Oberon - Component Pascal - Ada - C - Objective-C - C++ - Ocaml - Haskell - D - Go - Fortran - Lisp - Scheme

I remember trying to figure out how a certain lensing effect was done in the werkzeug a few years back. I really invested quite a bit of effort in this, and I never did work it out (yes, I did use all of the umm, obvious techniques for this). I'm really looking forward to finally figuring out this one thing that eluded me for so long. Farbrausch are the greatest. Long live Farbrausch.

Farbrausch are one of the most amazing demo scene groups out there today. I highly recommend watching the video captures of their demos on Youtube. Alternatively -- or perhaps more authentically -- you can download the executable demos and watch them on your computer. Highly worthwhile!

Heaven 7 by Exceed was always one of my favourites - watching it again now, it's still incredibly impressive:


For the longest time, my favourite was Prophecy.


I have been incredibly impressed with their demos over the years.

Their wikipedia entry lists 28 (!) members.

Did these guys work with any well known software/game companies/products?

Having 28 members isn't really considered a big accomplishment in the demoscene :-)

I can get together a group with 28 members in a single demoparty. We'll all be drunk idiots who forgot we signed up the day after, but we'd be 28 members.

Many of the Farbrausch guys work or have worked in the game industry. In fact, for a long time .theprodukkt (FR's somewhat more elitist and commercially feasible spinout) was planned to become a game company, but it never really did.

The same holds for most other good demomakers currently active. The entire Finnish demoscene makes mobile games, the Norwegians all work at ARM to make mobile graphics chips, and p01 works at Opera winning js1k competitions.

Meanwhile, the only somewhat active Spanish demoscener left codes Three.js at Google.

The Dutch are all unemployed.

ryg has been at RAD Game Tools for a while now, and mentioned yesterday on Twitter that he's been doing contract work on Valve's hardware experiments. [1]

  [1] http://twitter.com/#!/rygorous/status/190907866037760000

While at RAD he's also worked on the D3D stack for Larrabee under contract with Intel and on optimizing the low-level graphics layer for Iggy (RAD's Flash-based UI middleware) across several platforms.

Wow, I never thought VC++ and MFC are this extensively used in demoscene groups.

The PC demoscene started out on DOS and Watcom C++, and switched almost exclusively to Windows and Visual C++ around 1999. It was a natural choice at the time, as Linux wasn't ready for primetime and MSVC really was the best compiler around.

The choice of platform had to take the majority into account: most people didn't want to write demos that ordinary people couldn't watch. The opinion of programmers was not the most important factor anyway, simple because most people in the demoscene were not programmers -- there were musicians, graphics artists and all sorts of non-productive members besides.

Really, the demo scene, which started out in the 80's, was using Watcom C++? Watch the behind scenes video of Second Reality (1993). They're coding Pascal and (duh) assembly.

The demoscene was really born out of cracks/intros/loaders which means its origins are C64/Apple/Atari etc and assembly language.

In a very distance past, Watcom C++ used to be the best optimizing compiler for MS-DOS.

It was also the first to support extended memory in MS-DOS.

I'm not arguing the existence of Watcom C++ 9.5/386 :) But let's be clear the first version of Watcom C++ was released in 1993. To suggest the demoscene started there is ludicrous.

There I agree with you.

yeps. almost correct. scene started with c64. pc scene / first demo came out from future crew : second reality. also in 1996, smash designs created second reality 100% same fx via C64 (:


I don't understand your comment. There were lots of PC demos in the late 80's.

Early demos were also frequently attached to warez, so they had to be on the same platform that the game/app being cracked was on.

This is also very true of the Amiga scene back in the day.

That origin was really really early and not too relevant here.

There wasn't ever really a clean break afaik, and the association (some groups more than others) continued through at least the 1990s. Fairlight were active in both scenes for over a decade, for example, though from what I can tell the group did slowly internally divide in terms of who was focusing on warez v. demos. More to the point, though, I think the association with reverse-engineering culture had a significant impact on the technical culture and choice of tools/platforms. Unix culture had more of a C ethos, and less of a patch-asm-into-a-running-program type ethos.

in fact, razor 1911 is still releasing both demos and warez. I don't know that they have any in the running for the scene awards, but they are getting ranked.

Linux is still not ready for prime time as far as graphics is concerned. Window is still the strongest platform for graphically intense applications that push the GPU due to the quality of Windows drivers being better than Linux and Mac OS.

Demoscene and open source were distinct worlds.

Demoscene started on the 8bit world and as the PC world started focusing on MS-DOS, so did the coders.

As one of the goals of the demoscene was to see which groups were able to push the machine to the limits while minimizing the amount of code, the used algorithms were worth gold and thus kept secret.

So open source was a foreign word in the demoscene universe and everyone was happily coding the latest demo, instead of getting alternative OS to run on their PCs.

VC++ nearly exclusively. Some GCC'ers, but that's it, really. There's some more recent demos written in, say, Python, Java and C#, but they're pretty exceptional.

Demoscene is also nearly entirely Windows-only. It's a good platform for games, and thus for demos. Plus, culturally, demos are about as closed-source as you can get, so there's this natural repellent force between the hardcore Linux zealots and the hardcore demoscene geeks.


VC++ is much easier to work with than GCC on Windows (and I'm not talking only IDE but API support, debugging, binary size, etc)

Also, video driver support is best on Windows.

But of course, demos are made for Linux/OSX as well. You can try them on Wine as well under Linux, it's worth a shot.

The demoscene for Linux never really took off. Most of the demos I've seen were ports of existing ones.

> Demoscene is also nearly entirely Windows-only.

Pardon, I meant the PC Demoscene. Don't want angry C64 demosceners here.

For a demo you need every ounce of performance. http://willus.com/ccomp_benchmark2.shtml for a modern take on this.

I imagine that having a solid set of system libraries, useful abstractions, and a fixed ABI helps a great deal.

I didn't know this whole demoscene existed. This is amazing.

A good place to start looking around is here:


Remember that a youtube capture of a demo will be bigger, and not as good quality, as the actual demo.

But the processing power needed to run it will be less.

Depends if you're using Flash to play the video :-p

Farbrausch is one of the few very good reasons to be very proud of german programming!

What does nationality have to do with anything?

From what I remember as an observer, nationality always was a point of pride in the European demoscene, even when tongue in cheek.

Eh, no. Or, well, not the last 15 years at least.

And especially not in Germany. Saying you're proud of Germans when you're a German in Germany is considered scary.

Great find. Holy crap does this bring back some memories.

the werkkzeug IDE was beautiful - you could take apart every scene in The Popular Demo and see exactly what they did, all while rendering in real time. The interface wasn't pretty, but after working through that first rusty-iron texture, it made me feel like a genius.

Fabian just posted the companion blog post: http://fgiesen.wordpress.com/2012/04/15/if-in-doubt-go-to-th...

> To whom it may concern,

> Yes, this source code is a total mess. Good luck getting it to compile - I had to take out lots of things to make a source release possible.

Well that sounds promising for a release. Good for seeing the idea behind the code though and then write your own tools I guess.

Applications are open for YC Summer 2019

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact