How many demosceners in history were involved in creating commercially sold games in the past? Did they kill the scene? Weren't we all extremely proud that they did that? This is how I remember, X-Ample, Inflexion etc?
Even Reflex did the Centric game, commercially sold, did we curse them out for doing that? I think no one stopped respecting Quiss since that happened, so explain to me why we are treated differently here.

; -------------------------------------------------------------------------------- -------
; umult 32x32 zero page
; average 627.9 cycles
;
; summation plan:
;             . z04 z03 z02 z01 z00
;         +   : z13 z12 z11 z10   :
;           -------------------   :
;         . z14  t2  t1  t0   :   : 
;     +   : z23 z22 z21 z20   :   : 
;       -------------------   :   :
;     . z24  s2  s1  s0   :   :   :
; +   : z33 z32 z31 z30   :   :   :
; ---------------------------------
; =   X   A  r5  r4  r3  r2  r1  r0       

; -------------------------------------------------------------------------------- -------

*=$200
; tables with parity bias : even bias 0, odd bias 202

!align 255, 0, 0
sqr_lo: 
!for i,0,(511)-1 { !byte <((i*i)/4 + 202*(i&1)) }
!align 255, 0, 0
sqr_hi: 
!for i,0,(511)-1 { !byte >((i*i)/4 + 202*(i&1)) }
!align 255, 0, 0
neg_sqr_lo:
!for i,0,(511)-1 { !byte 255 - (<(((255-i)*(255-i))/4 + 202*((255-i)&1))) }
!align 255, 0, 0
neg_sqr_hi:
!for i,0,(511)-1 { !byte 255 - (>(((255-i)*(255-i))/4 + 202*((255-i)&1))) }

; ----------------------------------------------------------

; main entrypoint -- setup code can be in main memory
; in  : x0, x1, x2, x3 zp addresses, y0 in Y register, y1, y2, y3 in zp addresses
; out : 64 bit product of x*y in X A r5 r4 r3 r2 r1 r0 
umult32x32zeropage

; ============ setup for x
; x0 passed in zp location specified in _sqr_lo_0
		lda+1 x0
		sta+1 _sqr_hi_0 + 1
		eor #$FF
		sta+1 _neg_lo_0 + 1
		sta+1 _neg_hi_0 + 1
; x1 passed in zp location specified in _sqr_lo_1
		lda+1 x1
		sta+1 _sqr_hi_1 + 1
		eor #$FF
		sta+1 _neg_lo_1 + 1
		sta+1 _neg_hi_1 + 1
; x2 passed in zp location specified in _sqr_lo_2
		lda+1 x2
		sta+1 _sqr_hi_2 + 1
		eor #$FF
		sta+1 _neg_lo_2 + 1
		sta+1 _neg_hi_2 + 1
; z3 passed in zp location specified in _sqr_lo_3
		lda+1 x3
		sta+1 _sqr_hi_3 + 1
		eor #$FF
		sta+1 _neg_lo_3 + 1
		sta+1 _neg_hi_3 + 1
		jmp multiply
; ---------------------------------------------------------------------
*=$02 
multiply
; ============= multiply x by y0,y1,y2,y3
		; y0 in Y register on input
		ldx #<z00
		sec
		lda #<(muly0tail-umult32x8_branchout-1)
		bne umult32x8_same_x
muly0tail
		sta+1 z04
y1 = *+1
		ldy #0
		ldx #<z10
		lda #<(muly1tail-umult32x8_branchout-1)
		bne umult32x8_same_x
muly1tail
		sta+1 z14
y2 = *+1	
		ldy #0
		ldx #<z20
		lda #<(muly2tail-umult32x8_branchout-1)
		bne umult32x8_same_x
muly2tail
		sta+1 z24
y3 = *+1
		ldy #0
		ldx #<z30
		lda #<(summation-umult32x8_branchout-1)

; ---------------------------------------------------------------------
; 32x8 bit unsigned multiply -- zero page version
; x0,x1,x2,x3 inputs inline below; must have setup routine called first for x
; y0 is passed in Y register
; results are stored at a stride of 6 in zero page addresses starting at X register:
; z0 at X; z1 at X+6; z2 at X+12; z3 at X+18; z4 is returned in A
; requires carry set on entry
; on input A contains the relative branch to use as return address

umult32x8_same_x
		sta+1 umult32x8_branchout
; =========== P00 : calculate x0*y0  
x0 = *+1
_sqr_lo_0	lda sqr_lo,y
_neg_lo_0	adc neg_sqr_lo,y
		sta 0,x
_sqr_hi_0	lda sqr_hi,y
_neg_hi_0	adc neg_sqr_hi,y                     
; =========== P10
x1 = *+1
_sqr_lo_1	adc sqr_lo,y
		bcs _p10_carry
_neg_lo_1	adc neg_sqr_lo,y
		sta 6,x
_sqr_hi_1	lda sqr_hi,y
_p10_tail 
_neg_hi_1	adc neg_sqr_hi,y
; ============ P20
x2 = *+1
_sqr_lo_2	adc sqr_lo,y
		bcs _p20_carry
_neg_lo_2	adc neg_sqr_lo,y
		sta 12,x
_sqr_hi_2	lda sqr_hi,y
_p20_tail
_neg_hi_2	adc neg_sqr_hi,y
; ============ P30
x3 = *+1
_sqr_lo_3	adc sqr_lo,y
		bcs _p30_carry
_neg_lo_3	adc neg_sqr_lo,y
		sta 18,x
_sqr_hi_3	lda sqr_hi,y
_p30_tail	
_neg_hi_3	adc neg_sqr_hi,y ; z4 returned in A
umult32x8_branchout = *+1
		bcs muly0tail
; ============ out-of-line carry paths 
_p10_carry
		clc
		adc (_neg_lo_1+1),y
		sta 6,x
		lda #1 ; carry 1 in A, 0 or 1 in C
		adc (_sqr_hi_1+1),y
		jmp _p10_tail 
_p20_carry
		clc
		adc (_neg_lo_2+1),y
		sta 12,x
		lda #1 ; carry 1 in A, 0 or 1 in C
		adc (_sqr_hi_2+1),y

		jmp _p20_tail
_p30_carry
		clc
		adc (_neg_lo_3+1),y
		sta 18,x
		lda #1 ; carry 1 in A, 0 or 1 in C
		adc (_sqr_hi_3+1),y
		jmp _p30_tail 

; ============= sum results -- code must by in zero page

; results stride of 6 from umult32x8 so z00 need to be exactly where it is relative to following code
r3 = *
!byte 0
r4 = *
!byte 0
r5 = *
!byte 0
z00 = *
r0 = *
!byte 0
r1 = *
!byte 0
r2 = *
!byte 0
summation
		tax
		clc
		lda #01
z10 = *+1
		adc #10
		sta+1 r1 
		lda #02
		adc #11
		sta+1 t0
		lda #03
		adc #12
		sta+1 t0 + 6
z04 = *+1
		lda #04
		adc #13           
		sta+1 t0 + 12    
		bcc sum2       
		clc
		inc+1 z14   
sum2
t0 = *+1
		lda #0
z20 = *+1
		adc #20
		sta+1 r2 
		lda #1
		adc #21
		sta+1 s0
		lda #2
		adc #22
		sta+1 s0 + 6
z14 = *+1
		lda #3
		adc #23
		sta+1 s0 + 12
		bcc sum3
		clc
		inc+1 z24  
sum3
s0 = *+1
		lda #0
z30 = *+1
		adc #30
		sta+1 r3 
		lda #1
		adc #31
		sta+1 r4
		lda #2
		adc #32
		sta+1 r5  
z24 = *+1
		lda #3
		adc #33    
		bcs sum3finalcarry 
		rts
sum3finalcarry
		inx
		rts		

Well, since "care for" has 3 different meanings, you cannot blame "the man" for misunderstanding your imprecise communication. By the way, "English" not "english".

I urge some native english speaker to explain to the man

Not fixed and not for free, it is still the same 64kB. Cartridges which are easily available for standard C64 solve better the memory problems then C64U, REU is also available for standard C64. You still have the same problems how to fit things in memory.

What’s the big fuss about?

Take those away and mightn’t you just as well be making games for high-end PCs instead?

so explain to me why we are treated differently here.

I mean, the passphrase starts loading, but after the dirent check it immediately floods with error.

Every kind of involvement of sceners in such kind of "commercial" products context kills all the scene vibes for me. :(

Making stuff for c64 is solving puzzles how to fit in memory and make it run fast enough. Both those problems are kinda fixed for free on u64.

; ---------------------------------------------------------------------------------------
; umult 32x32 zero page
; average 668.2 cycles
;
; summation plan:
;             . z04 z03 z02 z01 z00
;         + z14 z13 z12 z11 z10   :
;           -------------------   :
;         .  t3  t2  t1  t0   :   : 
;     + z24 z23 z22 z21 z20   :   : 
;       -------------------   :   :
;     .  s3  s2  s1  s0   :   :   :
; + z34 z33 z32 z31 z30   :   :   :
; ---------------------------------
; =  r7  r6  r5  r4  r3  r2  r1  r0       

; ---------------------------------------------------------------------------------------

*=$200
; tables with parity bias : even bias 0, odd bias 202

!align 255, 0, 0
sqr_lo: 
!for i,0,(511)-1 { !byte <((i*i + 202*(i&1))/4) }
!align 255, 0, 0
sqr_hi: 
!for i,0,(511)-1 { !byte >((i*i + 202*(i&1))/4) }
!align 255, 0, 0
neg_sqr_lo:
!for i,0,(511)-1 { !byte 255 - (<(((255-i)*(255-i) + 202*((255-i)&1))/4)) }
!align 255, 0, 0
neg_sqr_hi:
!for i,0,(511)-1 { !byte 255 - (>(((255-i)*(255-i) + 202*((255-i)&1))/4)) }

; ----------------------------------------------------------

; main entrypoint -- setup code can be in main memory
; in  : x0, x1, x2, x3 zp addresses, y0 in Y register, y1, y2, y3 in zp addresses
; out : 32 bit product of x*y in A r6 r5 r4 r3 r2 r1 r0 
umult32x32zeropage

; ============ setup for x
; x0 passed in zp location specified in _sqr_lo_0
		lda x0
		sta _sqr_hi_0 + 1
		eor #$FF
		sta _neg_lo_0 + 1
		sta _neg_hi_0 + 1
; x1 passed in zp location specified in _sqr_lo_1
		lda x1
		sta _sqr_hi_1 + 1
		eor #$FF
		sta _neg_lo_1 + 1
		sta _neg_hi_1 + 1
; x2 passed in zp location specified in _sqr_lo_2
		lda x2
		sta _sqr_hi_2 + 1
		eor #$FF
		sta _neg_lo_2 + 1
		sta _neg_hi_2 + 1
; z3 passed in zp location specified in _sqr_lo_3
		lda x3
		sta _sqr_hi_3 + 1
		eor #$FF
		sta _neg_lo_3 + 1
		sta _neg_hi_3 + 1

; ============= multiply x by y0,y1,y2,y3
		; y0 in Y register on input
		ldx #<z00
		sec
		jsr umult32x8_same_x
y1 = *+1
		ldy #0
		ldx #<z10
		jsr umult32x8_same_x
y2 = *+1	
		ldy #0
		ldx #<z20
		jsr umult32x8_same_x
y3 = *+1
		ldy #0
		ldx #<z30
		jsr umult32x8_same_x

		jmp summation

; ---------------------------------------------------------------------
; 32x8 bit unsigned multiply -- zero page version
; x0,x1,x2,x3 inputs inline below; must have setup routine called first for x
; y0 is passed in Y register
; results are stored at a stride of 6 in zero page addresses starting at X register:
; z0 at X; z1 at X+6; z2 at X+12; z3 at X+18; z4 at X+24
; requires carry set on entry

*=#$02 
umult32x8_same_x
; =========== P00 : calculate x0*y0  
x0 = *+1
_sqr_lo_0	lda sqr_lo,y
_neg_lo_0	adc neg_sqr_lo,y
		sta 0,x
_sqr_hi_0	lda sqr_hi,y
_neg_hi_0	adc neg_sqr_hi,y                     
; =========== P10
x1 = *+1
_sqr_lo_1	adc sqr_lo,y
		bcs _p10_carry
_neg_lo_1	adc neg_sqr_lo,y
		sta 6,x
_sqr_hi_1	lda sqr_hi,y
_p10_tail 
_neg_hi_1	adc neg_sqr_hi,y
; ============ P20
x2 = *+1
_sqr_lo_2	adc sqr_lo,y
		bcs _p20_carry
_neg_lo_2	adc neg_sqr_lo,y
		sta 12,x
_sqr_hi_2	lda sqr_hi,y
_p20_tail
_neg_hi_2	adc neg_sqr_hi,y
; ============ P30
x3 = *+1
_sqr_lo_3	adc sqr_lo,y
		bcs _p30_carry
_neg_lo_3	adc neg_sqr_lo,y
		sta 18,x
_sqr_hi_3	lda sqr_hi,y
_p30_tail	
_neg_hi_3	adc neg_sqr_hi,y
		sta 24,x
		rts
; ============ out-of-line carry paths 
_p10_carry
		clc
		adc (_neg_lo_1+1),y
		sta 6,x
		lda #1 ; carry 1 in A, 0 or 1 in C
		adc (_sqr_hi_1+1),y
		jmp _p10_tail 
_p20_carry
		clc
		adc (_neg_lo_2+1),y
		sta 12,x
		lda #1 ; carry 1 in A, 0 or 1 in C
		adc (_sqr_hi_2+1),y
		jmp _p20_tail
_p30_carry
		clc
		adc (_neg_lo_3+1),y
		sta 18,x
		lda #1 ; carry 1 in A, 0 or 1 in C
		adc (_sqr_hi_3+1),y
		jmp _p30_tail 

; ============= sum results -- code must by in zero page

r4 = *
.byte 0
r5 = *
.byte 0
r6 = *
.byte 0
; results stride of 6 from umult32x8 so z00 need to be exactly where it is relative to following code
z00 = *
r0 = *
.byte 0
r1 = *
.byte 0
r2 = *
.byte 0
r3 = *
.byte 0
summation
		clc
		lda #01
z10 = *+1
		adc #10
		sta r1 
		lda #02
		adc #11
		sta t0
		lda #03
		adc #12
		sta t0 + 6
		lda #04
		adc #13
		sta t0 + 12
		lda #$00
		adc #14
		sta t0 + 18   ; ____ t calculated
t0 = *+1
		lda #0
z20 = *+1
		adc #20
		sta r2 
		lda #1
		adc #21
		sta s0
		lda #2
		adc #22
		sta s0 + 6
		lda #3
		adc #23
		sta s0 + 12
		lda #$00
		adc #24
		sta s0 + 18  ; ____ s calculated
s0 = *+1
		lda #0
z30 = *+1
		adc #30
		sta r3 
		lda #1
		adc #31
		sta r4
		lda #2
		adc #32
		sta r5    
		lda #3
		adc #33 
		sta r6
		lda #$00
		adc #34    ; last strided store
		rts

'j
It's a little bit sad but, hey, if it brings new sceners to C64 and if it brings us some new (real) C64 games, it's all fine.

I think the best thing that could have happened to the c64 scene is Commmodore offical, officially releasing a new compatible c64. You cant make this up in your wettest dream.

Actually, I've tried that, and it's not faster. It takes too long to setup the registers for REU. GeoRAM might have a chance.