Are people doing this on vintage hardware or new hardware? (Or emulation?)

If I was doing it (as an ex demo coder) I would do as much as I could in emulator to make my life easier and then test it on the hardware and hope for the best. Demo coding is one of those annoying things where real hardware is absolutely essential because you are often doing things which aren't properly emulated.

This demo didn't impress me that much, I was actually hoping for more. Maybe I've just forgotten how underpowered the Amiga OCS was for things like this? Second Reality by Future Crew on the PC is still my #1.

The Amiga 500 is extremely well emulated by now though.

A 33 MHz 486 CPU (the recommended spec for Second Reality to run smoothly) is MUCH more powerful than the 7 MHz 68000 of the A500... It's not just nearly 5 times faster, the 486 is way more cycle efficient, not to mention having a nice byte-addressable bitmap screen to draw into (vs 2-6 separate bitplanes).

So yeah you forgot how underpowered OCS Amigas are :)

That's just the CPU though. The Amiga has a bunch of custom chips for doing things you would have to do on the CPU in a PC.

For this Amiga demo it's mostly just the sound mixing the hardware handles. On a PC, mixing a couple of sound channels is pretty quick.

The Amiga hardware doesn't really help much with 3D effects, which the demo is loaded with. Audio is a big help for a 68000 but a 486 can mix 8 PCM channels and not even notice.

I believe a number of the devs who have been around for decades are still writing actual code with their preferred tools that run on Amiga. But I wouldn't be surprised if even there, most of the coding is being done in emulator, because the modern workflow is so much snappier that way.

However, the cross-platform build stack has gotten comprehensive, and straight modern hardware has become the method of choice for a lot of devs (including myself). There is an "Amiga Assembly" extension for VS Code which does a ton of heavy lifting for you, including setting up the build tools, and even grabbing a fork of the emulator that has DAP support so you can use VS Code's built-in debugger.

I personally use Neovim and a couple plugins for syntax highlighting and DAP support. As part of my build process, I run Python scripts which convert images and SFX to Amiga-friendly formats and assemble them into a custom binary file. I can't imagine how long that would have taken me to set up in an Amiga-only environment—Python is just too convenient.

I think a lot of what you see possible on Amiga today is thanks to modern tools allowing for very rapid iteration as well as some crazy preprocessing for effects that depend on lookup tables, etc.

FreePascal still has official support for creating Amiga binaries. I never tried it since I have no idea about how Amiga development works in general, but I tried FreePascal a bit for other systems and it seems pretty good (underrated?) (both the language and the compiler; fast, low on bloat, mostly safe memory, huge standard library).

So beautiful.

To be clear, this is a trailer/demo and not an actual game you can play?

This is a fully playable game on real hw :)

That while 8 main demo was the whole game. I've not seen any other gameplay videos for it.

Correct, the demo I linked is a non-interactive audiovisual demo that is designed to show off the leet coding and artistic skills of the team. ;) The OP is a fully-playable game, though.

When designing a game, you probably have to code a game engine that has certain capabilities and certain restrictions that persist through the entire game. But for these demos, you can write an entire isolated program that runs one 15-second visual effect before flushing it out and loading something totally different for the next effect. The effects are also usually designed with a lot of tricks that make them inflexible (like preprocessed data tables) and usually also take up every CPU cycle available, leaving none for stuff like game logic.

Any pointers on getting started?

I was fascinated by the Amiga when I was young, but they weren't widely available in my country.

Lately I've had an itch to do some retro programming work and was looking at the Amiga specifically. I tried Aztec C natively in UAE and VBCC as a cross-compiler, and got some command-line and hello world Intuition programs working.

But going beyond that has proven somewhat difficult. Documentation seems to be scattered all over the internet. I found a bunch of books on archive.org, but they mostly seem to focus on Intuition applications or beginner programmers.

I don't think you can follow the path originally trodden (competing on asmone 68K/hw with your fellow local coders, exchanging snippets of hw reg info and source) however there's a terrific short series of videos on youtube you might consider:

https://www.youtube.com/@WeijuWu

Wei-ju Wu lays out how to code directly on the hardware in an accessible manner and, importantly, from C, instead of 68K, with lots of examples. Then, if (or rather: when) you have to, you can always step down a level into 68K assembly to get better performance.

This is truly amazing. I've always adored demoscene, but not done anything other than consume, so I would appreciate more of those demos here if you can share some highlights of recent times.

Certainly! Here are some of my personal favorites from recent years. These all run on a stock A500 (with the ubiquitous trapdoor memory expansion).

https://www.youtube.com/watch?v=iD9xk3SDSYc

https://www.youtube.com/watch?v=_wpXOsEm7M0

https://www.youtube.com/watch?v=E0OzX7plbeY

https://www.youtube.com/watch?v=rIV4AhfugIs