fr-08: .the .product by farbrausch | 64k intro (2000) (720p HQ demoscene demo) 

ahaha, you got me to recall it. :))

damn i alrdy deleted that

Can you describe how was that to me?

@@akinoz uh, that's not really possible, imagine a knock and then a buzzing sound, slowly fading out. But the real kick is the visual part, how the image just gets torn apart and dances/vibrates in a circular-like motion until it settles.

I used to degauss large (29") CRT's using both a cordless drill and the degaussing coil 🙂

I had those disks and shared them at work.

Wow what a journey.

Yeah, still kicks ass 20 years later! :)

this brings tears to my eyes. I love the passion of this scene. Im only 30 now, so I missed the golden era of breakthroughs, but I love posts like this.

or rather unnecessary abstraction.

I wish. You should see the "microcontrollers" people use now - utterly overkill. The art of time and space efficiency is already being lost. Your microwave probably has a 40MHz ARM M0+ with 32KB

it did!

I only came hear to listen to that again :)

CrystalGamma Echo that!

KB is *the* man! :)

Yeah i can totally feel you!

Now I am watching this on a machine with 12 tabs open, my office suite running, a VM for work running and another torrent VM running. My CPU is barely working. Amazing how far we have come. Even still this demo is impressive though.

I ran it on a Pentium Pro 180 overclocked to 233 MHz right after it was released. My card was a Permedia 2, which was about even with your i740. It wasn't choppy for me, so the demo must have made a lot of use of L2 cache, which a PPro had lots of and a Celery 266 had none. Not too long ago, I ran the original exe file for this under Wine on Linux and it ran perfectly. 18 years ago, it pushed the limits of a Windows machine, and now you can run it under emulation.

This intro NEVER ran on i740. Only on NVidia Riva TNT cards. I so good remember, because had i740 this time.

John Cate Remember that Wine stands for Wine is not an emulator.

I always take these feelings as motivation to create more of what i want to see in the world :)

Based

the art is very much alive in today's 4k and 64k demos.

Говнокодером, и формошлепом. Делать crud - ума много не надо

​@@CoricComPlus чтобы тролить анонов в интернетах, ума надо еще меньше

+olemann77 There are still places were it's taken seriously, video game/console dev for instance..

basically all graphic rendering requires optimization and shortcuts or it would take way too long. the amount of fake optimization in physics simulations is also astonishing. current computers are nowhere near powerful enough that we could do away with optimization.

Except for maybe Apple themselves...

npm install demo-optimizer

Funny enough, I often encountered a form of premature optimization, where people believed that tweaking some loops deep within a web application was worth investing a couple of days.

I saw it a few days after it came out late in 2000. It doesn't seem like it was that long ago... But I was 27 then and 46 now, and I feel it. LOL

Someone gets it 😉

Do you know if they still have it up somewhere there website was down last I checked.

I still have it ❤

7:27 ритм той эпохи!

дата выхода 2000 год... 17 лет назад)

Дельный камент такой.... Прям много интересного ловишь.

Greetings from the future

@@jeremyzeimet3631 WOW, FUCK YEA!!!

Hello there! Yes, here I am admiring the start of the Farbrausch journey exactly 20 years back, which ended with an engine capable of outdoing id Tech 7 if ported to Vulkan and given PBR.

Howdee!

Nothing's changed, it's 23 now

Thanks for the explanation

No, it is not compulsory. Even without first hand knowledge this would be nonsensical. Otherwise there would be more demos with this effect.

True, but it would also take 2 hours to boot

@@gabrielwill404 Nope. Look at KolibriOS

Nothing more efficient than programming (and knowing how to do it) in assembly. You have to be very intimate with the hardware and memorize the ports and addresses of all the peripherals. These days though you can replace "hardware" with drivers because you have to write something that talks to the driver routines in an efficient manor since windows won't let you speak directly to the hardware. These programs would be much larger I'd imagine if you included all the calls to built-in subsystem routines...

​@@johnbarthol6493 ackshually the compiler can generate better assembly than a human can. Unless you want to be staring at instruction cycle tables all day.

@@DorperSystems Actually, the human always wins, because we can cheat. Use the compiler. Get it to output the assembly code. If you can improve on it, then you win. If you can't, then it's at least the best that the compiler can do. At least equal, possibly better. The human wins. And if you're already messing with CPU instructions, you're doing optimisation all wrong anyway. You should always optimise from the highest level downwards. Top down. You start with the algorithms. You start with the design to eliminate code - because, as Knuth has it, "the fastest code is the code that never runs". You don't optimise the CPU instructions of a sort, you re-arrange the design and algorithm so you don't even need to sort anything. Case in point, with this demo, the true optimisation is that everything is procedurally generated. That's the "secret sauce" to packing 1.9GB of data into 64KB. You don't store the data, you store the means of procedurally recreating it all. And that's how this demo, at the time, knocked everyone's socks off. Because it didn't try to pack down pre-rendered assets into 64KB, it procedurally created it all. If you're optimising CPU instructions and looking at instruction cycle tables all day, then you're doing it wrong. Always start at the very top and work your way down to the CPU instructions, when optimising. Because you'll get the biggest wins from algorithmic and design changes. You only gain cycles from playing with the CPU instructions. And, these days, there's zero point trying. CPUs have "out of order execution" - the CPU itself does all the neurotic CPU instruction scheduling itself. And it can always do a better job, as it's doing it dynamically, according to current CPU state, and you can't beat that with any static pre-rendered code (and it's all in hardware, so it's essentially free). I hear people heap praising on the supposed infallibility of optimising compilers. Nah, sorry, I can still beat them - not talking theory, as I'm actually doing it. The compiler is good at the neurotic CPU instruction stuff. But that's the last place to optimise, as the gains are tiny - a cycle or two here and there. What a compiler can't do is understand the purpose of the code. It won't change the algorithm. It won't eliminate whole swathes of code, realising that you can approach the problem in a completely different way. It can optimise your sort algorithm, sure, but only a human can re-imagine the entire program to eliminate the need to ever sort the data in the first place. I agree, though, that you should not really be "drag racing" against an optimising compiler. But not because you can't beat it - you actually can, if you really know what you're doing - but because you should be optimising the algorithm and design. Doing the highest level optimisations, as those are the biggest wins. And you should always optimise downwards - from the highest level to the lowest level, in that direction - simply because, logically, the high level is composed of the lowest level. If I start by optimising the CPU instructions in a function to win cycles, then move up to the higher level algorithm and realise I can greatly improve the whole program by using a better algorithm... then I'm removing that function I just spent forever optimising, as we're doing it a different way now. This is an inefficient way to approach it. You'll be constantly undoing your own hard work all the time. There is a directionality to optimisation and it's "top down". CPU instructions should be the very last thing you optimise - and if you've done a good job at the higher algorithmic levels, then you probably never need to get that low level. Carmack's genius with DOOM or Quake was not the assembly routines - most of it was written in C, and assembly only used to maximise how fast it could push pixels - but it was the use of BSP trees to rapidly eliminate as much geometry as possible. To do less work, by use of clever algorithms. To use an approximation for calculating square roots, realising that it doesn't have to be perfectly accurate - your optimising compiler might be able to improve square root code, but what it can't do is understanding. Understanding that, in this application, an approximation is good enough, so don't actually do the full accurate calculation, just use a quick and nasty approximation. Carmack is a human being, so he can use his understanding to realise where "good enough" is fine. But the machine does not understand the higher purpose of the code, so it cannot reason these things. And that's where the biggest and fastest wins are always won. In the design. At the algorithmic level. Top down, all the way. I've actually done it. It's pretty easy - taking a compiler's assembly code - to find optimisations that it didn't see. Compilers can't understand the purpose of the code, they can't judge where "good enough" will do and NOT, in fact, try to optimise a perfect algorithm, but actually use a faster approximation. They don't understand the higher purpose of the code, so they can't reason "actually, we should be using BSP trees and hash tables here" to alter the higher level algorithm. And that's always where the biggest wins are. Always start there first. If you do a good job at that level, then you'll find you never need touch individual CPU instructions. Knocking off a cycle here and there is linear. Switching from an "O(n^2)" to an "O(1)" algorithm is exponential. Also, I'd always recommend folks to learn assembly. Not because, in reality, you'll ever use it in anger much, if at all. But simply to understand what the CPU is doing - to learn to think like the machine - so that you generate the best code from the off. You can beat the machine because you possess a greater understanding of the whole picture, something the machine can't match (well, AI code generation can and will get there eventually, I guess. But, at that point, human coders are completely redundant anyway, so the point becomes moot. It won't be anyone's job anymore, so it no longer matters).

***** Me too, CPU and graphics load testing. :-)

Der, der Klassiker! :D

I'm gonna simplify because I'm not completely sure about this, instead of storing a texture, they would convert it into instructions how to create the texture and then it creates all the assets on launch

Can I use it as tool to make materials for a game?

Are you absolutely certain that you intended to type this here.

imjeffvader this was posted 5 years ago, sometime in 2013-2014. This wasn’t long before the RU-vid comment system was changed, fucking up the way that replies were handled.