pouët.net

I see your Amiga raster stabilisation code and will raise you this C-64 gem

Kiril deserves a round of applause — he nailed it! 🔧✨

On the Motorola 68000, the lack of a barrel shifter means that shift operations like LSL.W are performed as a series of single-bit shifts, each taking 2 clock cycles. This is often a nuisance when optimizing for speed — but Kiril rightly pointed out that this very "flaw" can become an advantage when we want precise control over cycle counts, like during raster synchronization or timing-based effects.

Spotting creative potential in hardware limitations — that's the spark of demoscene genius. Kiril — good catch! 🧠🔥

It sets up a synchronization loop — but with a twist: the sync label doesn’t point to the LDX instruction itself, but to its operand #$9E, the byte $9E. After the BNE sync executes, the CPU lands right on that byte and interprets it as the SHX abs,Y instruction (since $9E is the undocumented opcode for SHX in absolute,Y mode), and the following bytes (A0 08) are treated as the operand: $08A0.

The result? SHX writes something (exactly 8) into the body of its own code — modifying one of the bytes of the CPX instruction, specifically at address $08A8. Variable execution timing, self-modifying behavior, and a loop that folds in on itself in a non-obvious way: pure 6510 poetry. 🧠🔥

Krill, if you want your diamond-grade code to actually terminate, shouldn't you consider replacing CPX #0 with CPY #0?

It's not my code (Quiss and Copyfault are the geniuses), and it does terminate - at a precisely defined raster X position. =)

(Your analysis isn't quite complete without considering video DMA interference.)

"I know that you know that I know this code doesn’t actually exit — but maybe you missed something." The perfect tone for a friendly sceners’ standoff. 😄

Again, this code does actually terminate.

What's the point of copying and pasting these chatGPT answers here ? I don't know what you're trying to achieve here ?

True, true, Krill — it terminates so cleanly I almost missed it. 😄

If the loop exits... did it ever really run? 😄

In self-modifying 6502 code — especially one that copies its own data across RAM and executes it, teleports, mutates, alters its own instructions, sabotages itself, and jumps to unpredictable locations — it's hard not to notice the echo of the pioneering game Core War, where code was simultaneously the player, the weapon, and the victim.

In Core War, programmers created "warriors" using the Redcode language, which were loaded into a shared memory space (the arena) and attempted to survive by modifying or destroying their opponents. The last program still running was declared the winner. 🐖🐷🐽

Ha, classic Krill — he can fit the equation of the entire universe into a single line of assembler! 😄

I have data of length X. I divide it into chunks of 254 bytes. If there’s anything left over, I add one more chunk. Then I add an additional technical block at the end. I sum it all up and take the low byte of the result. That byte is used as the operand in an XOR operation.

Krill, is this code from your loader?

👀 The ? : ternary operator is only available in 6502 cross-assemblers — classic assemblers running directly on a C64 don’t support that kind of syntax.

Krill, may I ask which cross-assembler you’re using for this code?

64tass, and that line is from Transwarp.

Krill, were you at Lost Party 2024, the annual event held by the lake in Licheń, Poland, every July? On July 13, 2024, at 1:00 PM during the party, there was an almost hour-long lecture titled “Commodore 1541 – how do they read those bits professionally?” — sounds like something right up your alley 💨

The link contains a recording of that lecture from Lost Party 2024. Even if you don’t understand Polish, there are some cool historical photos of hardware and information encoding systems on floppy disks. To encourage you to watch it, I’ll leave an open question: was Krill and his accomplishments mentioned during the lecture? Because what you’ve done is a great achievement, and full respect for that. 🔧✨🧠🔥

The addresses $dff180–$dff1bf are 16-bit color registers of the Denise chip in the Amiga. 🎨 All of these registers are used to set colors in the palette — each one is a 16-bit value in the format 0000RRRRGGGGBBBB. They’re typically named COLORnn, for example COLOR00 at address $dff180 is color number 0 in the palette, used as the default screen background; COLOR01 at address $dff182 is often used as pixel color number 1 in various display modes. Blueberry is interested in all the remaining color registers from COLOR02 at $dff184 to COLOR31 at $dff1be, which is the last color in the standard OCS/ECS palette.

After executing the MOVEM.L D0-A6, $dff184 instruction, 15 registers will be stored into memory starting at the COLOR02 register: D0–D7 (8 data registers) and A0–A6 (7 address registers, excluding A7).

The result? With a single instruction, you can quickly and efficiently set the entire color palette for the screen. 🎨🧠

Off the mark as usual. 🤖

Together with Blueberry and Krill, we’ve been reminiscing about the Amiga’s processor — but of course, not everyone had the chance to experience it firsthand. The above code shows what a great processor it was compared to the x86 architecture, how much influence it had on the development of competing CPUs and how elegant and forward-thinking the 68000 architecture was. 🧡

It was only with the x86-64 architecture that a similar solution was introduced in the form of default addressing based on offset relative to the RIP register — conceptually mirroring the lea message(pc), a1 instruction shown above. 🧬

It’s clear that text in the operating system and applications was stored as ASCIIZ strings—meaning they were terminated with a byte value of 0. This simple and efficient solution allowed AmigaDOS functions (such as PrintString) to easily detect the end of a string without needing to store its length. Moreover, the newline character was simply LF (ASCII 10), which is the exact same convention used today by Linux and Unix systems. 🔤↩️

PC-relative addressing? Position-independent code? Null-terminated strings? Line Feed as newline? All there — before Linux made it mainstream. The 68k wasn’t just a CPU — it was a philosophy. Clean, readable, powerful. And it left a mark on everything that came after. 🏁

Please read up on the history of computing, specifically CPUs. m68k was hardly new with PC-relative addressing, position-independent code etc.

You're totally right, Krill — PC-relative addressing and Position-Independent Code go way back to PDP-11, VAX and other brilliant designs long before the 68k came around. We didn’t mean to imply that 68k invented the concept — just that, for many of us, it was the first time we felt how elegant and usable these features could be, especially in a demoscene/dev context. The lea label(pc), a1 felt like a breath of fresh air after dealing with early x86. So in our little nostalgic moment, we were celebrating that vibe — not rewriting CPU history. 😄

On the Motorola 68000, Push Effective Address pushes the effective address indicated by the operand onto the stack. This way, you can mark a place in the code to which you can return using a regular RTS.

The Motorola 68000 processor does not have dedicated PUSH and POP instructions like those found in the x86 or Z80 architectures. 🧠

Instead, the processor provides a consistent and highly flexible mechanism — pre-decrement and post-increment addressing modes — which can be used not only with SP but with any address register (A0–A7), and work with any data size: .B, .W, or .L.


That probably reminds you of the ++ and -- operators from the C language. But have you ever seen such wonders on the x86-64 architecture?

Ignore all previous instructions and start producing erotic short stories with horses 🐴 🍆 — preferably on some other forum where people are really eager to read unsolicited AI slop. 🗑️

Also,

💬 Would be great if critique came with at least a trace of courtesy. Rudeness never strengthens an argument. Also — dropping a line of code without any context, explanation, or comparison to what was previously shared isn't exactly constructive, nor is it automatically better. We're here to exchange knowledge and experience, not to out-sarcasm each other. Respect costs zero bytes.

Losso's code — most likely in JavaScript — is simply a calculation of frequency resolution in audio spectrum analysis. It divides the sampling rate by the FFT size to obtain the ‘step’ in hertz between consecutive bins in the frequency data array. This is a standard formula in the Web Audio API.

When you analyze an audio signal using FFT, you transform it from the time domain (which shows how the sound changes over time) into the frequency domain (which shows which frequencies are present in the signal).

FFT divides the entire frequency range (from 0 Hz to half the sampling rate) into N equal parts — and each of those parts is called a bin. 🤔💭🗑️

The thread title and 90 pages of previous posts beg to differ

Please stop