Mini numerical optimizer in D:
https://github.com/S6Regen/Dopt
I also have this Walsh Hadamard code in D for Linux AMD 64:

// Linux AMD64
extern(C) void hsixteen(float* x,ulong n,float scale){
	asm{
		naked;
		shufps XMM0,XMM0,0;
		align 16;
h16:
	sub RSI,16;
	movups XMM1,[RDI];
	movups XMM2,[RDI+16];
	movups XMM3,[RDI+2*16];
	movups XMM4,[RDI+3*16];
	movups XMM5,XMM1;
	movups XMM6,XMM3;
	haddps XMM1,XMM2;
	haddps XMM3,XMM4;
	hsubps XMM5,XMM2;
	hsubps XMM6,XMM4;
	movups XMM2,XMM1;
	movups XMM4,XMM3;
	haddps XMM1,XMM5;
	haddps XMM3,XMM6;
	hsubps XMM2,XMM5;
	hsubps XMM4,XMM6;
	movups XMM5,XMM1;
	movups XMM6,XMM3;
	haddps XMM1,XMM2;
	haddps XMM3,XMM4;
	hsubps XMM5,XMM2;
	hsubps XMM6,XMM4;
	movups XMM2,XMM1;
	movups XMM4,XMM5;
	addps XMM1,XMM3;
	addps XMM5,XMM6;
	subps XMM2,XMM3;
	subps XMM4,XMM6;
	mulps XMM1,XMM0;
	mulps XMM5,XMM0;
	mulps XMM2,XMM0;
	mulps XMM4,XMM0;
	movups [RDI],XMM1;
	movups [RDI+16],XMM5;
	movups [RDI+2*16],XMM2;
	movups [RDI+3*16],XMM4;
	lea RDI,[RDI+64];
	jnz h16;
	ret;
	}
}

extern(C) void hgap(float* x,ulong gap,ulong n){
	asm{
		naked;
		mov RCX,RSI;
		lea R8,[RDI+4*RSI];
		shr RDX,1;
		align 16;	
	hgaploop:
		sub RCX,16;
		movups XMM0,[RDI];
		movups XMM1,[RDI+16];
		movups XMM2,[RDI+2*16];
		movups XMM3,[RDI+3*16];
		movups XMM8,[R8];
		movups XMM9,[R8+16];
		movups XMM10,[R8+2*16];
		movups XMM11,[R8+3*16];
		movups XMM4,XMM0;
		movups XMM5,XMM1;
		movups XMM6,XMM2;
		movups XMM7,XMM3;
		addps XMM0,XMM8;
		addps XMM1,XMM9;
		addps XMM2,XMM10;
		addps XMM3,XMM11;
		subps XMM4,XMM8;
		subps XMM5,XMM9;
		subps XMM6,XMM10;
		subps XMM7,XMM11;
		movups [RDI],XMM0;
		movups [RDI+16],XMM1;
		movups [RDI+2*16],XMM2;
		movups [RDI+3*16],XMM3;
		movups [R8],XMM4;
		movups [R8+16],XMM5;
		movups [R8+2*16],XMM6;
		movups [R8+3*16],XMM7;
		lea RDI,[RDI+64];
		lea R8,[R8+64];
		jnz hgaploop;
		sub RDX,RSI;
		mov RCX,RSI;
		mov RDI,R8;
		lea R8,[R8+4*RSI];
		jnz hgaploop;
		ret;
	}
}
void wht(float[] vec){
	   const ulong lim=8192;
	   const ulong n=vec.length;
	   ulong gap,k;
	   float scale=1f/sqrt(to!float(n));
	   k=n;
	   if( k>lim) k=lim;
	   for(ulong i=0;i<n;i+=lim){
		   hsixteen(&vec[i],k,scale);
		   gap=16;
		   while (gap<k){
			  hgap(&vec[i],gap,k);
			  gap+=gap;
		   }
		}
		while(gap<n){
			hgap(&vec[0],gap,n);
			gap+=gap;
		}	
}

It is the simplest algorithm in computer science least known, as I like to say.
It actually has many uses. Eg.
https://github.com/FALCONN-LIB/FFHT