Revision (Demoscene)

I wish I was there now :D

About the "why no more Linux releases" discussion, BTW, normal demos should not be affected by cultural disagreements such as which init system or which audio framework to use, I think everyone can agree on using SDL2, which will transparently utilize whatever other software you want it to. To utilize GPU APIs, link GLEW (or gl-rs) statically, it's not rocket science.

For size limited demos, the solution is shaping out to be github.com/faemiyah/dnload, but it currently does not work well on Linux (only freeHugsBSD). Ideally, dnload will allow you to dynamically utilize SDL2 and OpenGL calls directly from the driver/library files without ld-linux, of course in a minimal size footprint.

Attached: SDL_logo.png (179x99, 20.44K)

Only plarform that matters is C64, waiting for the oldschool demo compo

Usually Revision oldskools have only had a couple of C64 entries, though, unfortunately.

yeah i know, waiting for X2018

Me too. Shame to sofascene X properly, you pretty much need to go to facebook for phone cam streams

I can wait the extra 2-3 days for the proper videos on youtube, all demos are captured on youtube in really good quallity.

Since SDL is not a part of Linux, the kernel, you should have to count the binary size of the library too unless you have a Linux + a bunch of libraries and userspace code category.

lmao this demo scene doesn't allow linux??

nothing stops you from making a linux demo, maybe this party has windows only rule though I'm not sure. There's a bunch of linux demos

There were some demos that used X or svgalib in the 90's. Also there was bb for aalib. But you can also just use plain ASCII.

#!/usr/bin/perl## Alternative Party 2003 invitation intro# by Mikko "Ravel" Tuomela on 18-Nov-2002# version 1.1 20-Nov-2002# email: [email protected]## usage: # $ ./invi.pl# (normal mode, you may have to export COLUMNS and export LINES)## $ ./invi.pl x y# (x and y are the desired geometry, 10 < x,y < 100)# $ ./invi.pl x y n# (x,y = geometry, n = number of objects, default=2)use strict;$| = 1;my $maxcols = 100;my $maxrows = 100;my $cols;my $rows;if($ARGV[0] eq "" || $ARGV[1] eq "") { $cols = $ENV{COLUMNS} - 2; $rows = $ENV{LINES} - 2;} else { $cols = $ARGV[0] - 2; $rows = $ARGV[1] - 2;}if($cols > $maxcols || $rows > $maxrows) { print "Your terminal is too big\!\n"; die;}if($cols < 10 || $rows < 10) { print "COLUMNS and LINES must be at least 10\!\n"; die;}my $amount = 1;if($ARGV[2] ne "") { $amount = $ARGV[2] - 1;}$rows -= 1;my @dist;my @altdist;print "precalc...\n";for my $y (0 .. 200) { for my $x (0 .. 200) { $dist[$x][$y] = int(sqrt($x ** 2 + $y ** 2)); $altdist[$x][$y] = int(sqrt(abs($x ** 2 - $y ** 2))); }}my @coords;for my $center (0 .. $amount) { $coords[$center] = [rand $cols, rand $rows, rand 2, rand 2, 0, 0]; $coords[$center][4] = int($coords[$center][0]); $coords[$center][5] = int($coords[$center][1]); if(rand 10 < 5) { $coords[$center][2] = -$coords[$center][2]; } if(rand 10 < 5) { $coords[$center][3] = -$coords[$center][3]; }}my @chars = ("OOOO ", " .,+o\$M", "OO OO ", "M\¤o+,. ", "O O O O ", "OO ", ".. MM ");my @text = (" Ravel presents ", " an invitation to ", " Alternative Party 2003 ", " 10th-12th January 2003 ", " Gloria Helsinki Finland ", " altparty.org/ ", " Press Ctrl-C to stop ");my $part = 0;my $introlength = 7;my $charset;my $message;my $height;my $type = 0;my $round = 0;my $full;print "\033c";while(1) { $charset = $chars[$part]; $message = $text[$part]; $part++; if($part == $introlength) { $part = 0; } for my $time (0 .. 100) { print "\033[H"; $full = ""; for my $y (0 .. $rows) { for my $x (0 .. $cols) { $height = 0; for my $cent (0 .. $amount) { if($round == 0 || $round == 1) { if($type == 0) { $height += $dist[abs($x - $coords[$cent][4])] [abs($y - $coords[$cent][5])] % 8; } else { $height += $altdist[abs($x - $coords[$cent][4])] [abs($y - $coords[$cent][5])] % 8; } } else { if($type == 0) { $height += (-1) ** ($cent + 2) * $dist[abs($x - $coords[$cent][4])] [abs($y - $coords[$cent][5])]; } else { $height += (-1) ** ($cent + 2) * $altdist[abs($x - int($coords[$cent][4]))] [abs($y - int($coords[$cent][5]))]; } } } if($round == 0 || $round == 1) { $height = int($height / ($amount + 1)) % 8; } else { $height = int($height % 8); } $full .= substr($charset, $height, 1); } $full .= "\n"; } print $full . "\033[4m" . $message . "\033[m"; for my $cent (0 .. $amount) { $coords[$cent][0] += $coords[$cent][2]; $coords[$cent][1] += $coords[$cent][3]; if($coords[$cent][0] < 0 || $coords[$cent][0] > $cols) { $coords[$cent][2] = -$coords[$cent][2]; } if($coords[$cent][1] < 0 || $coords[$cent][1] > $rows) { $coords[$cent][3] = -$coords[$cent][3]; } $coords[$cent][4] = int($coords[$cent][0]); $coords[$cent][5] = int($coords[$cent][1]); } } if($part == 0) { if($type == 0) { $type = 1; } else { $type = 0; } } if($part == 0) { $round++; } if($round == 4) { $round = 0; }}

Attached: Robotic Liberation by PWP (VIC-20)-2SdGkkp1aq8.mp4 (450x360, 8.76M)

What was that demo made for? It doesn't work that well on my modern machine as it scrolls through everything quickly. I had to add a sleep statement in the loop so I could actually see what it was doing.

Yeah nice GNU/Linux/systemd/Xorg/etc argument, but if we talk of "desktop Linux" now in the normie sense, SDL2 can and very well should be considered a standard part of any stack where games or demos are expected to run. Steam guarantees SDL2 on their "Linux" version as a part of their bundled libraries. And many if not most games and emulators use it. It's basically perfect for demos as it's really straightforward to use in a handful of C calls and covers all you need (non-buggy windowing, OpenGL context, keyboard input (press ESC to quit in some compo rules), audio output).

If you want to go down the "you should have to count the binary size of the library" -path, then the only "true" 4ks and 64ks released to date would be on older platforms like DOS and C64, and even then they typically use parts of the ROM or OS, such as the text characters.

Says right in the header:
Think I had an AMD Duron clocked at like 800 MHz back then. Unless maybe I was still using the AMD K6 400 MHz. Can't remember.

The thing about demos is it's traditionally a hardware-gangbanging orgy, so using these libraries, and even depending on OS is kinda lame. DOS was pretty much just used as a loader. Same thing on Amiga, etc. Half the point was finding new hardware tricks and doing cool stuff with them.

I agree that close to the metal demos are charming and that the programmers of such computing feats are very respectable. But "modern demos" as in a real time graphical ARTISTIC (yeah sceners hate that but it's true) software application which only uses the OS's abstract interfaces, are kinda like their own genre. There is plenty of space for "both", and "both" are exciting to me in their own ways. It's really a spectrum of programmer constraints from which everybody must often choose what the desired "level" will be for what they create. The way the product should be judged and how the creative process should be felt by the maker, depend much on what "level" of demo they wanna do.

using sdl to create a window and a framebuffer and then just using your own routines to draw complex shit into that framebuffer is cool I think. There's even a really advanced demo doing some nice stuff all in software and all coded in assembly. It's also available for linux 2ith X11, it's called Kiss my ASSembler

At that point, why not be a man and use Linux's, the kernel's, framebuffer?

You don't even need that. Some user posted his bootloader demo on here sometime last year. Well it was more like a breakout game or something, but same concept.
If you really want an OS, FreeDOS works, and it's a stable platform, unlike Linux and its toolchain that are constantly changing.

that was actually me :

I said yo use sdl because then your program will work on all platforms supported by sdl which is a lot.

QEMU also works on many platforms.

running your bootloader demo in qemu will be much slower than the same program as normal userspace process. I don't discourage anyone from writing bare metal shit, I did that myself and currently work on c64 demo, it just depends.

files.scene.org/browse/parties/2018/revision18/

The demos are all up. I didn't even know these were still a thing. I'm now teaching myself sizecoding.

Attached: gawld.mp4 (720x480, 8.14M)

in4k.github.io/
lofibucket.com/articles/64k_intro.html
github.com/faemiyah/

thx m80

Attached: 1501631890815.png (333x500, 102.88K)

also to get started fast, github.com/armak/Leviathan-2.0

github.com/phaazon/spectra

doesn't that defeat the purpose of creating a demo?

Attached: whatthe.jpg (880x495, 69.86K)

tbh, TempleOS is best choice if you need any OS
pfffft ebin XD

Like I said it many times, some people view it only as art and don't wanna put autistic amount of programming effort into it, just get fast, educational and motivating results. Maybe they're really new to it, maybe they wanna focus on choreography, design or the GPU side or things like shading and post processing techniques. One of my most respectable and skilled scene friends frequently does Unity demos and another one of my scene friends (from a local uni) got 2nd place from Assembly with an Unreal Engine prod. This is only a free hobby, and sometimes you have to pick some compromises and focus on delivering your visions instead of repeatedly giving up on projects as they get stale from technical roadblocks. I'm sure most sceners understand the positive values of "not invented here", but I don't think it's wise to try bite more than you can swallow at once

if you're doing straight software rendering to a plain framebuffer you will not break any new ground or push any limits, using sdl over direct framebuffer of the os will be less than 1% of your overhead... I don't understand why you think it's such a weird idea.
here's my wip c64 demo part
youtu.be/y-jKrkjyQRU

a bit older version of the same part on real hardware
youtu.be/nmn2wp_BQ-8

SDL2 on my machine is 1.2 MiB. So if we assume it's 1% overhead, your resulting program would be 117.5 MiB. That seems like a huge file size for a demo.

they did say less than, though from that number even that would be shooting a bit high. A lot of these demos work in the kilobyte range.

as in you wouldn't measure them with megabytes

Recheck your math. If it was only .5% of the size overhead, your resulting program would be ~235 MiB. I was being generous by rounding to one.

meant for

I was doing mental math, but yes you are right. I'm saying the user there was technically right in saying it was less than 1 percent.

The larger demo competitions are 64kilobytes. That is tiny! Yet for these guys they make it into so much. It is something amazing.

I meant the perfomance not the size... not every pc demo is 64kb. Obviously for a size production you wouldn't use sdl...

More over, I said one could use SDL to have a portable demo, which would mean that the size of the library would not be included (unless you want to include all versions for each OS / platform). Small PC demos use directX or openGL, obviously, I think SDL is on similar level, it could have been just installed on the system and ready to be used by your program.

And even if you want to include SDL in your program, say, you want to compile it statically with your code. Remember that SDL is really broad, it can handle lots and lots of screen formats, different color depths, planar graphics... And I proposed to use SDL just to get a framebuffer in a normalised way, all your bliting routines would be yours (you can use SDL's but writing your own software renderer is half the fun). SDL is open source, it's quite small and organised, it's licence allows you to compile it statically. It's quite easy to just take a part of it that you want, for example, said creation of a window and frame buffer. That's a tiny part of (compiled) code.

Dynamic linking or dlopen()ing SDL is fair and square on non-windows OSs IMO. Windows has win32 for really efficient windowing, and since "Linux" has no official API besides syscalls, it's just fine to treat the most common installed software stack as part of the "base platform" in this case. Even the last party I attended has "allowed to link to common system (for example glibc, OpenGL and SDL)" in the rules instanssi.org/2018/kompot/#96 and another pretty big local one has "Latest Ubuntu (18.04)", whatever that means, and I sure as hell hope it means the "average ubuntu after installing a few common applications and games" (SDL2). assembly.org/summer18/demoscene/rules

What the fuck are you talking about? are you one of those markov chain bots?