Upload index.html

index.html

@@ -1281,12 +1281,17 @@
                 if (!this.gl) throw Error("No WebGL");
 
                 this.isWebGL2 = typeof WebGL2RenderingContext !== 'undefined' && this.gl instanceof WebGL2RenderingContext;
+                this.colorBufferFloatExt = null;
+                this.colorBufferHalfFloatExt = null;
                 if (!this.isWebGL2) {
                     if (!this.gl.getExtension('OES_texture_float')) throw Error('Need OES_texture_float');
                     if (!this.gl.getExtension('WEBGL_color_buffer_float')) throw Error('Need WEBGL_color_buffer_float for float render targets');
-                } else if (!this.gl.getExtension('EXT_color_buffer_float')) {
-                    console.warn('No EXT_color_buffer_float');
+                } else {
+                    this.colorBufferFloatExt = this.gl.getExtension('EXT_color_buffer_float');
+                    this.colorBufferHalfFloatExt = this.gl.getExtension('EXT_color_buffer_half_float');
+                    if (!this.colorBufferFloatExt && !this.colorBufferHalfFloatExt) console.warn('No floating-point color-buffer extension');
                 }
+                this.supportsF16RenderTarget = Boolean(this.isWebGL2 && (this.colorBufferFloatExt || this.colorBufferHalfFloatExt));
 
                 this.devValidatePrograms = false;
                 this.wasmKernels = null;
@@ -1401,8 +1406,8 @@
                     await new Promise(resolve=>setTimeout(resolve,0));
                 }
             }
-            _getTexturePoolKey(w,h){return `${w}x${h}`;}
-            _getPooledTexture(w,h){const key=this._getTexturePoolKey(w,h);const bucket=this.texturePool.get(key);if(bucket&&bucket.length>0){return bucket.pop();}return null;}
+            _getTexturePoolKey(w,h,dtype='f32'){return `${w}x${h}:${dtype}`;}
+            _getPooledTexture(w,h,dtype='f32'){const key=this._getTexturePoolKey(w,h,dtype);const bucket=this.texturePool.get(key);if(bucket&&bucket.length>0){return bucket.pop();}return null;}
             getUniformLocationCached(program,name){if(!program)return null;if(!program.uniformLocations)program.uniformLocations=new Map();if(program.uniformLocations.has(name))return program.uniformLocations.get(name);const location=this.gl.getUniformLocation(program,name);program.uniformLocations.set(name,location);return location;}
             warmProgram(fragmentShaderSource){const vs2=`#version 300 es\nprecision highp float;in vec2 a_position;void main(){gl_Position=vec4(a_position,0.,1.);}`;const vs1=`precision highp float;attribute vec2 a_position;void main(){gl_Position=vec4(a_position,0.,1.);}`;return this._createProgram(this.isWebGL2?vs2:vs1,fragmentShaderSource);}
             _createShader(t,s){const sh=this.gl.createShader(t);this.gl.shaderSource(sh,s);this.gl.compileShader(sh);if(!this.gl.getShaderParameter(sh,this.gl.COMPILE_STATUS)){const e=`Shader Err: ${this.gl.getShaderInfoLog(sh)}\nSrc:\n${s}`;this.gl.deleteShader(sh);throw Error(e);}return sh;}
@@ -1434,20 +1439,22 @@
                 this.programs.set(fs,p);
                 return p;
             }
-            createTexture(w,h,d=null){
+            createTexture(w,h,d=null,dtype='f32'){
                 GMLValidate.integer(w,'texture width',{min:1,max:this.maxTextureSize});
                 GMLValidate.integer(h,'texture height',{min:1,max:this.maxTextureSize});
+                dtype=GMLDType.normalize(dtype);
+                const storageDtype=(dtype==='f16'&&this.supportsF16RenderTarget)?'f16':'f32';
                 if(d!==null){
-                    if(!(d instanceof Float32Array)) throw new GMLValidationError('Texture data must be a Float32Array or null.');
-                    if(d.length!==w*h*4) throw new GMLValidationError(`Texture upload requires ${w*h*4} float values, got ${d.length}.`);
+                    if(!(d instanceof Float32Array)) throw new GMLValidationError('Texture upload data must be Float32Array or null.');
+                    if(d.length!==w*h*4) throw new GMLValidationError(`Texture upload requires ${w*h*4} values, got ${d.length}.`);
                     GMLValidate.data(d,d.length,'texture data');
                 }
                 const gl=this.gl;
-                let t=this._getPooledTexture(w,h);
+                let t=this._getPooledTexture(w,h,storageDtype);
                 const reused=Boolean(t);
                 if(!t){t=gl.createTexture();t.__id=textureIdCounter++;}
                 gl.bindTexture(gl.TEXTURE_2D,t);
-                const iF=this.isWebGL2?gl.RGBA32F:gl.RGBA;
+                const iF=this.isWebGL2?(storageDtype==='f16'?gl.RGBA16F:gl.RGBA32F):gl.RGBA;
                 if(!reused){
                     gl.texImage2D(gl.TEXTURE_2D,0,iF,w,h,0,gl.RGBA,gl.FLOAT,d);
                     gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
@@ -1459,7 +1466,7 @@
                     gl.texSubImage2D(gl.TEXTURE_2D,0,0,0,w,h,gl.RGBA,gl.FLOAT,d);
                 }
                 gl.bindTexture(gl.TEXTURE_2D,null);
-                t.__meta={width:w,height:h};
+                t.__meta={width:w,height:h,dtype:storageDtype};
                 t.__refs=1;
                 return t;
             }
@@ -1649,7 +1656,7 @@
                 texture.__refs=0;
                 const meta=texture.__meta;
                 if(meta&&meta.width>0&&meta.height>0){
-                    const key=this._getTexturePoolKey(meta.width,meta.height),bucket=this.texturePool.get(key)||[];
+                    const key=this._getTexturePoolKey(meta.width,meta.height,meta.dtype||'f32'),bucket=this.texturePool.get(key)||[];
                     if(bucket.length<this.maxTexturePoolPerBucket){bucket.push(texture);this.texturePool.set(key,bucket);return;}
                 }
                 if(texture.__meta)delete texture.__meta;
@@ -1734,8 +1741,8 @@
             },
 
             data(data, expectedSize, label = 'Tensor data') {
-                if (!(data instanceof Float32Array) && !Array.isArray(data)) {
-                    this.fail(`${label} must be an Array or Float32Array. Got ${data === null ? 'null' : typeof data}.`);
+                if (!(data instanceof Float32Array) && !(data instanceof Int8Array) && !Array.isArray(data)) {
+                    this.fail(`${label} must be an Array, Float32Array, or Int8Array. Got ${data === null ? 'null' : typeof data}.`);
                 }
                 if (data.length !== expectedSize) {
                     this.fail(`${label} has ${data.length} values but the shape requires ${expectedSize}.`, 'Make the data rectangular or fix the explicit shape.');
@@ -1817,6 +1824,94 @@
             }
         };
 
+        const GMLDType = {
+            names: new Set(['f32','f16','i8']),
+            normalize(value){
+                const v=String(value??'f32').trim().toLowerCase();
+                const aliases={float:'f32',float32:'f32',fp32:'f32',half:'f16',float16:'f16',fp16:'f16',int8:'i8'};
+                const out=aliases[v]||v;
+                if(!this.names.has(out))throw new GMLValidationError(`Unsupported dtype '${value}'.`,`Use f32, f16, or i8.`);
+                return out;
+            },
+            floatToHalfBits(value){
+                const f32=new Float32Array(1),u32=new Uint32Array(f32.buffer);f32[0]=Number(value)||0;const x=u32[0];
+                const sign=(x>>>16)&0x8000,exp=(x>>>23)&0xff,mant=x&0x7fffff;
+                if(exp===0xff)return sign|(mant?0x7e00:0x7c00);
+                let e=exp-127+15;
+                if(e>=31)return sign|0x7c00;
+                if(e<=0){if(e<-10)return sign;let m=(mant|0x800000)>>(1-e);return sign+((m+0x1000)>>13);}
+                return sign|(e<<10)|((mant+0x1000)>>13);
+            },
+            halfBitsToFloat(bits){
+                const sign=(bits&0x8000)?-1:1,exp=(bits>>>10)&31,mant=bits&1023;
+                if(exp===0)return sign*Math.pow(2,-14)*(mant/1024);
+                if(exp===31)return mant?NaN:sign*Infinity;
+                return sign*Math.pow(2,exp-15)*(1+mant/1024);
+            },
+            roundF16(value){return this.halfBitsToFloat(this.floatToHalfBits(value));},
+            quantizeI8(values){
+                let maxAbs=0;for(let i=0;i<values.length;i++)maxAbs=Math.max(maxAbs,Math.abs(Number(values[i])||0));
+                const scale=maxAbs>0?maxAbs/127:1,q=new Int8Array(values.length);
+                for(let i=0;i<values.length;i++)q[i]=Math.max(-127,Math.min(127,Math.round((Number(values[i])||0)/scale)));
+                return {data:q,scale,zeroPoint:0};
+            },
+            toFloat32(data,dtype='f32',quantization=null){
+                dtype=this.normalize(dtype);
+                if(data instanceof Float32Array&&dtype!=='i8')return new Float32Array(data);
+                const out=new Float32Array(data?.length||0);
+                if(dtype==='i8'){
+                    const scale=quantization?.scale??1,zero=quantization?.zeroPoint??0;
+                    for(let i=0;i<out.length;i++)out[i]=(Number(data[i])-zero)*scale;
+                }else for(let i=0;i<out.length;i++)out[i]=Number(data[i]);
+                return out;
+            },
+            cast(data,fromDtype,toDtype,quantization=null){
+                toDtype=this.normalize(toDtype);const f=this.toFloat32(data,fromDtype,quantization);
+                if(toDtype==='f32')return {data:f,quantization:null};
+                if(toDtype==='f16'){for(let i=0;i<f.length;i++)f[i]=this.roundF16(f[i]);return {data:f,quantization:null};}
+                const q=this.quantizeI8(f);return {data:q.data,quantization:{scale:q.scale,zeroPoint:q.zeroPoint}};
+            },
+            promote(tensors){
+                const ds=tensors.map(t=>t?.dtype||'f32');
+                if(ds.includes('f32')||ds.includes('i8'))return 'f32';
+                return ds.length&&ds.every(d=>d==='f16')?'f16':'f32';
+            }
+        };
+
+        const GMLCpu = {
+            matmul(a,b,bias=null){
+                if(a.shape.length!==2||b.shape.length!==2||a.shape[1]!==b.shape[0])throw new GMLValidationError(`CPU matmul shape mismatch [${a.shape}] @ [${b.shape}].`);
+                const A=a.numericData(),B=b.numericData(),M=a.shape[0],K=a.shape[1],N=b.shape[1],out=new Float32Array(M*N),bv=bias?bias.numericData():null;
+                for(let m=0;m<M;m++)for(let n=0;n<N;n++){let acc=bv?bv[n]:0;for(let k=0;k<K;k++)acc+=A[m*K+k]*B[k*N+n];out[m*N+n]=acc;}
+                return new Tensor(out,[M,N],false,bias?'cpu_linear':'cpu_matmul',a.runner,{device:'cpu',dtype:GMLDType.promote([a,b])});
+            },
+            activate(t,kind){
+                const x=t.numericData(),out=new Float32Array(x.length);
+                for(let i=0;i<x.length;i++){const v=x[i];switch(kind){case'relu':out[i]=Math.max(0,v);break;case'relu6':out[i]=Math.min(6,Math.max(0,v));break;case'gelu':out[i]=v>10?v:(v<-10?0:0.5*v*(1+Math.tanh(0.7978845608*(v+0.044715*v*v*v))));break;case'silu':case'swish':out[i]=v/(1+Math.exp(-v));break;case'tanh':out[i]=Math.tanh(v);break;case'sigmoid':out[i]=v>=0?1/(1+Math.exp(-v)):Math.exp(v)/(1+Math.exp(v));break;case'exp':out[i]=Math.exp(v);break;case'log':out[i]=Math.log(v);break;case'sqrt':out[i]=Math.sqrt(v);break;case'abs':out[i]=Math.abs(v);break;case'square':out[i]=v*v;break;case'negate':out[i]=-v;break;default:out[i]=v;}}
+                return new Tensor(out,t.shape.slice(),false,`cpu_${kind}`,t.runner,{device:'cpu',dtype:t.dtype==='f16'?'f16':'f32'});
+            },
+            elementwise(name,a,b){
+                const A=a.numericData(), B=b instanceof Tensor?b.numericData():null, out=new Float32Array(A.length), scalar=typeof b==='number'?b:null;
+                const same=B&&B.length===A.length, trailing=B&&a.shape.length===2&&((b.shape.length===1&&b.shape[0]===a.shape[1])||(b.shape.length===2&&b.shape[0]===1&&b.shape[1]===a.shape[1]));
+                if(B&&!same&&!trailing&&!((B.length===1)))throw new GMLValidationError(`CPU ${name} does not support broadcast [${a.shape}] with [${b.shape}].`,`Move tensors to GPU for broader broadcast support.`);
+                const cols=a.shape.length===2?a.shape[1]:A.length;
+                for(let i=0;i<A.length;i++){const y=scalar!==null?scalar:(B.length===1?B[0]:(trailing?B[i%cols]:B[i]));switch(name){case'Add':out[i]=A[i]+y;break;case'Sub':out[i]=A[i]-y;break;case'Mul':out[i]=A[i]*y;break;case'Div':out[i]=A[i]/y;break;}}
+                const dtype=GMLDType.promote([a,b instanceof Tensor?b:null].filter(Boolean));return new Tensor(out,a.shape.slice(),false,`cpu_${name.toLowerCase()}`,a.runner,{device:'cpu',dtype});
+            },
+            reduce(t,mean=false){const x=t.numericData();let acc=0;for(let i=0;i<x.length;i++)acc+=x[i];if(mean&&x.length)acc/=x.length;return new Tensor(new Float32Array([acc]),[1],false,mean?'cpu_mean':'cpu_sum',t.runner,{device:'cpu',dtype:t.dtype==='f16'?'f16':'f32'});},
+            transpose(t){if(t.shape.length!==2)throw new GMLValidationError('CPU transpose currently expects a rank-2 tensor.');const [R,C]=t.shape,x=t.numericData(),out=new Float32Array(x.length);for(let r=0;r<R;r++)for(let c=0;c<C;c++)out[c*R+r]=x[r*C+c];return new Tensor(out,[C,R],false,'cpu_transpose',t.runner,{device:'cpu',dtype:t.dtype});},
+            softmax(t,logMode=false){const width=t.shape[t.shape.length-1],rows=t.size/width,x=t.numericData(),out=new Float32Array(x.length);for(let r=0;r<rows;r++){const base=r*width;let mx=-Infinity;for(let c=0;c<width;c++)mx=Math.max(mx,x[base+c]);let sum=0;for(let c=0;c<width;c++)sum+=Math.exp(x[base+c]-mx);const lz=Math.log(sum)+mx;for(let c=0;c<width;c++)out[base+c]=logMode?x[base+c]-lz:Math.exp(x[base+c]-lz);}return new Tensor(out,t.shape.slice(),false,logMode?'cpu_log_softmax':'cpu_softmax',t.runner,{device:'cpu',dtype:t.dtype==='f16'?'f16':'f32'});},
+            norm(t,rms=false,epsilon=1e-5){const width=t.shape[t.shape.length-1],rows=t.size/width,x=t.numericData(),out=new Float32Array(x.length);for(let r=0;r<rows;r++){const base=r*width;let mean=0,sq=0;for(let c=0;c<width;c++){mean+=x[base+c];sq+=x[base+c]*x[base+c];}mean/=width;sq/=width;const inv=1/Math.sqrt((rms?sq:(sq-mean*mean))+epsilon);for(let c=0;c<width;c++)out[base+c]=(x[base+c]-(rms?0:mean))*inv;}return new Tensor(out,t.shape.slice(),false,rms?'cpu_rms_norm':'cpu_layer_norm',t.runner,{device:'cpu',dtype:t.dtype==='f16'?'f16':'f32'});},
+            apply(opName,inputs,ctx={}){
+                const tensors=inputs.filter(x=>x instanceof Tensor);if(!tensors.length)return null;const a=tensors[0];
+                if(['Add','Sub','Mul','Div'].includes(opName))return this.elementwise(opName,a,inputs[1]);
+                const unary={Square:'square',Negate:'negate',Abs:'abs',Exp:'exp',Log:'log',Sqrt:'sqrt',ReLU:'relu',ReLU6:'relu6',GELU:'gelu',SiLU:'silu',Sigmoid:'sigmoid',Tanh:'tanh'};if(unary[opName])return this.activate(a,unary[opName]);
+                if(opName==='Sum')return this.reduce(a,false);if(opName==='Mean')return this.reduce(a,true);if(opName==='Transpose')return this.transpose(a);if(opName==='Softmax')return this.softmax(a,false);if(opName==='LogSoftmax')return this.softmax(a,true);if(opName==='LayerNorm')return this.norm(a,false,ctx.epsilon??1e-5);if(opName==='RMSNorm')return this.norm(a,true,ctx.epsilon??1e-6);
+                if(opName==='Reshape'){const shape=inputs[1];return new Tensor(a.numericData(),Array.from(shape),false,'cpu_reshape',a.runner,{device:'cpu',dtype:a.dtype});}
+                return null;
+            }
+        };
+
         // --- Tensor Class ---
         let tensorIdCounter=0; let textureIdCounter=0; class Tensor{
             constructor(data,shape,requires_grad=false,name=null,webglRunner=null,options={}){
@@ -1833,14 +1928,17 @@
                 this.size=shapeInfo.size;
                 this.name=name||`t${this.id}`;
                 this._destroyed=false;
-                this.__gmlProperties=new Set(['shape','size','requires_grad','grad','name']);
-                this.__gmlMethods=new Set(['backward','relu','relu6','leaky_relu','elu','selu','gelu','silu','swish','softplus','mish','sigmoid','tanh','softmax','log_softmax','layer_norm','rms_norm','l2_norm','rope','causal_mask','window_mask','shift','causal_conv1d','affine_scan','repeat_interleave','patchify','frame','slice','concat','dropout','sum','mean','square','abs','exp','log','sqrt','transpose','reshape','permute','batched_matmul','zero_grad']);
+                this.__gmlProperties=new Set(['shape','size','requires_grad','grad','name','dtype','device']);
+                this.__gmlMethods=new Set(['backward','relu','relu6','leaky_relu','elu','selu','gelu','silu','swish','softplus','mish','sigmoid','tanh','softmax','log_softmax','layer_norm','rms_norm','l2_norm','rope','causal_mask','window_mask','shift','causal_conv1d','affine_scan','repeat_interleave','patchify','frame','slice','concat','dropout','sum','mean','square','abs','exp','log','sqrt','transpose','reshape','permute','batched_matmul','zero_grad','to','cpu','gpu','f32','f16','i8']);
+                this.dtype=GMLDType.normalize(options.dtype || (data instanceof Int8Array?'i8':(webglRunner?._allocationDtype||'f32')));
+                this.quantization=options.quantization?{...options.quantization}:null;
+                this.storageDtype=this.dtype;
                 this.data=null;
                 this.texture=null;
                 this.texWidth=0;
                 this.texHeight=0;
                 this.rowAligned=false;
-                this.requires_grad=requires_grad;
+                this.requires_grad=this.dtype==='i8'?false:requires_grad;
                 this._grad=null;
                 this._grad_fn=null;
                 this._ctx=null;
@@ -1848,20 +1946,18 @@
                 this._materializing=false;
                 this._deferAllocation=Boolean(options?.deferAllocation);
                 if(!this.runner&&requires_grad)console.warn(`Tensor ${this.name} requires_grad but no runner.`);
-                if(data instanceof Float32Array){
+                if(data instanceof Float32Array||data instanceof Int8Array||Array.isArray(data)){
                     if(data.length!==this.size)throw Error(`Data size ${data.length} mismatch with shape product ${this.size} for ${this.name}`);
-                    this.data=data;
-                }else if(Array.isArray(data)){
-                    if(data.length!==this.size)throw Error(`Data array length ${data.length} mismatch with shape product ${this.size} for ${this.name}`);
-                    this.data=new Float32Array(data);
-                }else if(data===null&&this.runner&&!this._deferAllocation){
+                    const sourceDtype=data instanceof Int8Array?'i8':'f32';
+                    const cast=GMLDType.cast(data,sourceDtype,this.dtype,options.quantization||null);this.data=cast.data;this.quantization=cast.quantization;
+                }else if(data===null&&this.runner&&!this._deferAllocation&&options.device!=='cpu'){
                     this._allocateGPUTexture();
                 }else if(data!==null){
-                    throw Error(`Invalid data type for ${this.name}. Expected Float32Array, Array, or null.`);
+                    throw Error(`Invalid data type for ${this.name}. Expected numeric Array, Float32Array, Int8Array, or null.`);
                 }
-                if(this.data&&this.runner){
+                if(this.data&&this.runner&&options.device!=='cpu'){
                     this.toGPU();
-                }else if(!this.data&&!this.texture&&this.runner&&!this._deferAllocation){
+                }else if(!this.data&&!this.texture&&this.runner&&!this._deferAllocation&&options.device!=='cpu'){
                     this._allocateGPUTexture();
                 }
             }
@@ -1910,7 +2006,8 @@
                 if(this.size===0){this.texWidth=0;this.texHeight=0;if(this.texture)this.runner.deleteTexture(this.texture);this.texture=null;return;}
                 const{width,height,rowAligned=false}=this.runner._getTextureSizeForShape(this.shape);
                 if(this.texture&&(this.texWidth!==width||this.texHeight!==height)){this.runner.deleteTexture(this.texture);this.texture=null;}
-                if(!this.texture){this.texture=this.runner.createTexture(width,height,null);}
+                if(!this.texture){this.texture=this.runner.createTexture(width,height,null,this.dtype==='i8'?'f32':this.dtype);}
+                this.storageDtype=this.texture?.__meta?.dtype||(this.dtype==='i8'?'f32':this.dtype);
                 this.texWidth=width;
                 this.texHeight=height;
                 this.rowAligned=Boolean(rowAligned);
@@ -1922,7 +2019,8 @@
                 if(!this.data){if(!this.texture)this._allocateGPUTexture();return;}
                 if(this.size===0)return;
                 if(!this.texture)this._allocateGPUTexture();
-                const p=this.runner._padDataForTexture(this.data,this.texWidth,this.texHeight);
+                const uploadData=this.numericData();
+                const p=this.runner._padDataForTexture(uploadData,this.texWidth,this.texHeight);
                 const gl=this.runner.gl;
                 gl.bindTexture(gl.TEXTURE_2D,this.texture);
                 gl.texSubImage2D(gl.TEXTURE_2D,0,0,0,this.texWidth,this.texHeight,gl.RGBA,gl.FLOAT,p);
@@ -1932,18 +2030,40 @@
                 this._assertUsable('toCPU()');
                 if(this._lazyPlan){this.ensureMaterialized();}
                 if(!this.runner||!this.texture)return this.data;
-                if(this.data instanceof Float32Array)return this.data;
-                if(this.texWidth===0||this.texHeight===0)return new Float32Array(0);
-                this.data=this.runner.readTexture(this);
-                if(this.data===null){console.error(`Failed to read GPU data for ${this.name}.`);return null;}
+                if(this.data instanceof Float32Array||this.data instanceof Int8Array)return this.data;
+                if(this.texWidth===0||this.texHeight===0)return this.dtype==='i8'?new Int8Array(0):new Float32Array(0);
+                const read=this.runner.readTexture(this);
+                if(read===null){console.error(`Failed to read GPU data for ${this.name}.`);return null;}
+                const cast=GMLDType.cast(read,'f32',this.dtype,this.quantization);this.data=cast.data;if(this.dtype!=='i8')this.quantization=cast.quantization;
                 return this.data;
             }
+            numericData(){
+                this._assertUsable('numericData()');
+                const raw=(this.data instanceof Float32Array||this.data instanceof Int8Array)?this.data:this.toCPU();
+                if(raw==null)return null;
+                return GMLDType.toFloat32(raw,this.dtype,this.quantization);
+            }
+            get device(){return (this.texture||this._lazyPlan)?'gpu':'cpu';}
+            cpu(){
+                this._assertUsable('cpu()');if(this._lazyPlan)this.ensureMaterialized();if(this.texture){this.toCPU();this.runner.deleteTexture(this.texture);this.texture=null;this.texWidth=0;this.texHeight=0;this.rowAligned=false;}return this;
+            }
+            gpu(){
+                this._assertUsable('gpu()');if(!this.runner)throw new GMLValidationError(`Tensor '${this.name}' has no GPU runtime.`);this.toGPU();this.data=null;return this;
+            }
+            _castInPlace(dtype){
+                dtype=GMLDType.normalize(dtype);if(dtype===this.dtype)return this;const wasGpu=Boolean(this.texture);const f=this.numericData();if(this.texture){this.runner.deleteTexture(this.texture);this.texture=null;this.texWidth=0;this.texHeight=0;}
+                const cast=GMLDType.cast(f,'f32',dtype,null);this.dtype=dtype;this.data=cast.data;this.quantization=cast.quantization;if(dtype==='i8')this.requires_grad=false;if(wasGpu)this.gpu();return this;
+            }
+            f32(){return this._castInPlace('f32');}
+            f16(){return this._castInPlace('f16');}
+            i8(){return this._castInPlace('i8');}
+            to(target){const t=String(target??'').toLowerCase();if(t==='cpu')return this.cpu();if(t==='gpu'||t==='webgl')return this.gpu();return this._castInPlace(t);}
             static viewOf(source,newShape,name=null){
                 GMLValidate.tensor(source,'view source',{runner:source.runner,requireData:true});
                 const info=GMLValidate.shape(newShape,'view shape');
                 if(info.size!==source.size)throw new GMLValidationError(`View size mismatch: [${source.shape}] has ${source.size} values but [${newShape}] requires ${info.size}.`);
                 if(source._lazyPlan)source.ensureMaterialized();
-                const view=new Tensor(null,newShape,false,name||`${source.name}_view`,source.runner,{deferAllocation:true});
+                const view=new Tensor(null,newShape,false,name||`${source.name}_view`,source.runner,{deferAllocation:true,dtype:source.dtype,quantization:source.quantization});
                 if(source.texture&&source.runner){
                     view.texture=source.runner.retainTexture(source.texture);
                     view.texWidth=source.texWidth;view.texHeight=source.texHeight;
@@ -1964,7 +2084,7 @@
                     else if (this._grad_fn) gradStatus = "Pending (Intermediate)";
                     else gradStatus = "Yes (Leaf)";
                 }
-                return `Tensor(${this.name}, sh=[${this.shape.join(',')}]${d}, grad=${gradStatus}${t})`;
+                return `Tensor(${this.name}, shape=[${this.shape.join(',')}], dtype=${this.dtype}, device=${this.device}, grad=${gradStatus}${t})`;
             }
             async backward(gradient=null){this._assertUsable('backward()');if(this._lazyPlan)this.ensureMaterialized();if(!this.requires_grad){console.warn(`Cannot call backward() on ${this.name} because requires_grad is false.`);return;}if(!this.runner)throw Error(`No WebGL runner available for backward pass of ${this.name}.`);const visited=new Set();const nodes=[];function build(n){if(!n||visited.has(n.id)||!(n instanceof Tensor))return;visited.add(n.id);if(n._ctx&&n._ctx.inputs)n._ctx.inputs.forEach(i=>build(i));nodes.push(n);}build(this);if(this._grad&&this._grad!==gradient&&gradient !== null){console.warn(`Tensor ${this.name} already has a gradient. It will be overwritten by the new gradient in backward().`);this._grad.destroy();this._grad=null;}if(!this._grad || gradient !== null){ if(gradient){if(!(gradient instanceof Tensor))throw Error("Gradient passed to backward() must be a Tensor.");if(gradient.shape.toString()!==this.shape.toString())throw Error(`Gradient shape mismatch for ${this.name}: expected ${this.shape}, got ${gradient.shape}.`);this._grad=gradient;if(!this._grad.texture && this._grad.size > 0)this._grad.toGPU();}else{if(this.size!==1)console.warn(`Implicit gradient of 1.0 created for non-scalar Tensor ${this.name} (shape [${this.shape}]) in backward().`);const ones=new Float32Array(this.size).fill(1.0);this._grad=new Tensor(ones,this.shape,false,`${this.name}_grad_implicit`,this.runner);if(this._grad.size > 0) this._grad.toGPU();}this._grad.requires_grad=false;} const yieldEveryNodes=4; for(let i=nodes.length-1;i>=0;i--){if(((nodes.length-1-i)%yieldEveryNodes)===0)await GMLUiScheduler.checkpoint();const node=nodes[i];if(node._grad_fn){if(node._grad){if(node._grad._lazyPlan)node._grad.ensureMaterialized();if(!node._grad.texture&&node._grad.size>0)node._grad.toGPU();const gradBeforeBackward=node._grad;const maybePromise=node._grad_fn(node._ctx);if(maybePromise&&typeof maybePromise.then==='function')await maybePromise;if(node!==this&&node._grad===gradBeforeBackward){gradBeforeBackward.destroy();node._grad=null;}}else if(node.requires_grad){console.warn(` Node ${node.name} requires grad but has no gradient computed during backward pass.`);}}else if(node.requires_grad&&!node._grad&&node!==this){console.warn(` Leaf Tensor ${node.name} requires grad but has no gradient after backward pass (and is not the initial Tensor).`);}}}
             add(other){if(!(other instanceof Tensor))throw Error("Addition requires both operands to be Tensors.");return Add.apply({runner:this.runner, inputs:[this, other]}, this,other);}
@@ -1973,7 +2093,7 @@
             div(other){return Div.apply({runner:this.runner, inputs:[this, other]}, this,other);}
             square(){ return Square.apply({runner:this.runner, inputs:[this]}, this); }
             transpose(){return Transpose.apply({runner:this.runner, inputs:[this]}, this);}
-            matmul(other){if(!(other instanceof Tensor))throw Error("Matrix multiplication requires both operands to be Tensors.");return MatMul.apply({runner:this.runner, inputs:[this, other]}, this,other);}
+            matmul(other){if(!(other instanceof Tensor))throw Error("Matrix multiplication requires both operands to be Tensors.");if(this.device==='cpu'&&other.device==='cpu'&&!this.requires_grad&&!other.requires_grad)return GMLCpu.matmul(this,other);return MatMul.apply({runner:this.runner, inputs:[this, other]}, this,other);}
             batched_matmul(other,transposeA=false,transposeB=false){if(!(other instanceof Tensor))throw Error('batched_matmul requires a Tensor.');return BatchedMatMul.apply({runner:this.runner,inputs:[this,other],disableFusion:true},this,other,transposeA,transposeB);}
             permute(axes){return Permute.apply({runner:this.runner,inputs:[this],disableFusion:true},this,axes);}
             relu(){ return ReLU.apply({runner:this.runner, inputs:[this]}, this); }
@@ -2053,6 +2173,13 @@
                     }
                 }
                 const output_req_grad=tensorsIn.some(t=>t instanceof Tensor && t.requires_grad);
+                const cpuInputs=tensorsIn.filter(t=>t.device==='cpu');
+                if(cpuInputs.length){
+                    if(cpuInputs.length!==tensorsIn.length)throw new GMLValidationError(`${this.name} received tensors on different devices.`,`Move them explicitly with .cpu() or .gpu(); GML never silently crosses devices.`);
+                    if(output_req_grad)throw new GMLValidationError(`CPU autograd for ${this.name} is not enabled in v0.3.`,`Use .gpu() for training; CPU execution is intended for inference, debugging, and speed comparisons.`);
+                    const cpuOutput=GMLCpu.apply(this.name,inputs,ctx);if(cpuOutput)return cpuOutput;
+                    throw new GMLValidationError(`${this.name} has no CPU kernel yet.`,`Call .gpu() before this operation. GML will not silently move it for you.`);
+                }
                 if (!output_req_grad && runner.fusionCompiler && !ctx.disableFusion) {
                     const fusedOutput = runner.fusionCompiler.tryCreateTensor(this.name, inputs, ctx);
                     if (fusedOutput) {
@@ -2060,7 +2187,10 @@
                     }
                 }
                 for(const input of tensorsIn){if(input instanceof Tensor && !input.texture && input.size>0)input.toGPU();}
-                const output=this.forward(ctx,...inputs); 
+                const previousAllocationDtype=runner._allocationDtype;
+                runner._allocationDtype=ctx.outputDtype||GMLDType.promote(tensorsIn);
+                let output;
+                try{output=this.forward(ctx,...inputs);}finally{runner._allocationDtype=previousAllocationDtype;}
                 if(!(output instanceof Tensor)) {
                      throw new Error(`${this.name}.forward must return a Tensor (returned type: ${typeof output})`);
                 }
@@ -4059,6 +4189,55 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
             }
         }
 
+        class GMLCharLanguageModel {
+            constructor(text,parserRef,context=null){
+                this.parser=parserRef;this.trainingText=String(text??'');const chars=GMLUnicode.graphemes(this.trainingText);if(chars.length<3)throw new GMLValidationError('A language-model training string needs at least 3 characters.');
+                this.vocab=[];const seen=new Set();for(const ch of chars)if(!seen.has(ch)){seen.add(ch);this.vocab.push(ch);}this.context=context||this._inferContext(chars);this.transitions=new Map();this.unigram=new Map();
+                for(let i=0;i<chars.length;i++)this.unigram.set(chars[i],(this.unigram.get(chars[i])||0)+1);
+                for(let n=1;n<=this.context;n++)for(let i=n;i<chars.length;i++){const key=this._key(chars.slice(i-n,i));const next=chars[i];let counts=this.transitions.get(key);if(!counts){counts=new Map();this.transitions.set(key,counts);}counts.set(next,(counts.get(next)||0)+1);}
+                this.task='language';this.seed=parserRef?.seedValue??1337;this.__gmlObjectType='char_lm';this.__gmlProperties=new Set(['task','context','vocab','seed']);this.__gmlMethods=new Set(['generate','summary','save']);
+            }
+            _key(parts){return parts.join('
');}
+            _inferContext(chars){for(let n=1;n<=Math.min(8,chars.length-1);n++){const nextBy=new Map();let ambiguous=false;for(let i=n;i<chars.length;i++){const k=this._key(chars.slice(i-n,i)),v=chars[i];if(nextBy.has(k)&&nextBy.get(k)!==v){ambiguous=true;break;}nextBy.set(k,v);}if(!ambiguous)return n;}return Math.min(8,chars.length-1);}
+            _best(counts){let best=null,bestN=-1;for(const [ch,n] of counts||[]){if(n>bestN){best=ch;bestN=n;}}return best;}
+            generate(prompt,count=32,temperature=0){GMLValidate.integer(count,'generate length',{min:0,max:1000000});let chars=GMLUnicode.graphemes(String(prompt??''));for(let step=0;step<count;step++){let counts=null;for(let n=Math.min(this.context,chars.length);n>=1&&!counts;n--)counts=this.transitions.get(this._key(chars.slice(chars.length-n)));if(!counts)counts=this.unigram;let next;if(Number(temperature)>0&&counts.size>1){const temp=Math.max(1e-4,Number(temperature)),items=[...counts.entries()],weights=items.map(([,n])=>Math.pow(n,1/temp)),total=weights.reduce((a,b)=>a+b,0),r=(this.parser?.nextRandom?.()??Math.random())*total;let acc=0;for(let i=0;i<items.length;i++){acc+=weights[i];if(r<=acc){next=items[i][0];break;}}}else next=this._best(counts);if(next==null)break;chars.push(next);}return chars.join('');}
+            summary(){return `CharLM(context=${this.context}, vocab=${this.vocab.length}, training_chars=${GMLUnicode.length(this.trainingText)}, seed=${this.seed})`;}
+            toString(){return `CharLanguageModel {
+  context: ${this.context},
+  vocab: ${JSON.stringify(this.vocab)},
+  trainingChars: ${GMLUnicode.length(this.trainingText)},
+  seed: ${this.seed}
+}`;}
+            toBundleMeta(){return {kind:'char_lm',task:this.task,context:this.context,vocab:this.vocab,seed:this.seed,trainingText:this.trainingText,transitions:[...this.transitions].map(([k,v])=>[k,[...v]])};}
+            save(filename='char-lm.gmlm'){return GMLModelBundle.download(this,filename,typeof getEditorSource==='function'?getEditorSource():'');}
+        }
+
+        const GMLModelBundle = {
+            magic:'GMLMOD1\n',
+            _tensorRecord(tensor,name,offset){
+                const floats=tensor.numericData();let bytes,dtype=tensor.dtype,quantization=tensor.quantization?{...tensor.quantization}:null;
+                if(dtype==='i8'){const q=tensor.data instanceof Int8Array?tensor.data:GMLDType.quantizeI8(floats).data;bytes=new Uint8Array(q.buffer,q.byteOffset,q.byteLength);}
+                else if(dtype==='f16'){const half=new Uint16Array(floats.length);for(let i=0;i<floats.length;i++)half[i]=GMLDType.floatToHalfBits(floats[i]);bytes=new Uint8Array(half.buffer);}
+                else bytes=new Uint8Array(floats.buffer,floats.byteOffset,floats.byteLength);
+                return {meta:{name,dtype,shape:tensor.shape.slice(),offset,length:bytes.byteLength,quantization},bytes:new Uint8Array(bytes)};
+            },
+            encode(model,source=''){
+                let params=[],modelMeta;
+                if(model instanceof GMLModel){params=model.layers.flatMap((l,i)=>[[`layer${i+1}.weight`,l.W],[`layer${i+1}.bias`,l.B]]);modelMeta={kind:'mlp',layerSizes:model.layerSizes,activation:model.activation,task:model.task,seed:model.seed,inputEncoding:model.inputEncoding,preprocessor:model.preprocessor?.enabled?{enabled:true,mean:Array.from(model.preprocessor.mean.numericData()),scale:Array.from(model.preprocessor.scale.numericData())}:{enabled:false},targetPreprocessor:model.targetPreprocessor||null};}
+                else if(model instanceof GMLCustomArchitectureModel){params=[...model.scope.params.entries()];modelMeta={kind:'custom',architecture:model.scope.name,functionName:model.functionName,task:model.task};}
+                else if(model instanceof GMLCharLanguageModel){modelMeta=model.toBundleMeta();}
+                else throw new GMLValidationError('save() expects a model created by learn(), mlp(), or architecture().model().');
+                let offset=0;const records=[];for(const [name,t] of params){const rec=this._tensorRecord(t,name,offset);records.push(rec);offset+=rec.bytes.byteLength;}
+                const header={format:'gml-model',version:1,runtime:'gml-v0.3',createdAt:new Date().toISOString(),source:String(source||''),model:modelMeta,tensors:records.map(r=>r.meta)};
+                const headerBytes=new TextEncoder().encode(JSON.stringify(header)),magicBytes=new TextEncoder().encode(this.magic),prefix=magicBytes.length+8,total=prefix+headerBytes.length+offset,buffer=new ArrayBuffer(total),view=new Uint8Array(buffer);view.set(magicBytes,0);new DataView(buffer).setBigUint64(magicBytes.length,BigInt(headerBytes.length),true);view.set(headerBytes,prefix);let cursor=prefix+headerBytes.length;for(const r of records){view.set(r.bytes,cursor);cursor+=r.bytes.length;}return buffer;
+            },
+            decode(buffer){const bytes=new Uint8Array(buffer),magicBytes=new TextEncoder().encode(this.magic);for(let i=0;i<magicBytes.length;i++)if(bytes[i]!==magicBytes[i])throw new Error('Not a GML model bundle.');const n=Number(new DataView(buffer).getBigUint64(magicBytes.length,true)),start=magicBytes.length+8,header=JSON.parse(new TextDecoder().decode(bytes.subarray(start,start+n))),dataStart=start+n;return {header,tensorBytes(name){const t=header.tensors.find(x=>x.name===name);if(!t)throw new Error(`Tensor '${name}' not found.`);return bytes.slice(dataStart+t.offset,dataStart+t.offset+t.length);}};},
+            _decodeTensor(record,raw,runner){let values;if(record.dtype==='i8'){values=new Int8Array(raw.buffer,raw.byteOffset,raw.byteLength);return new Tensor(new Int8Array(values),record.shape,true,record.name,runner,{dtype:'i8',quantization:record.quantization||{scale:1,zeroPoint:0}});}if(record.dtype==='f16'){const count=raw.byteLength/2,u=new Uint16Array(raw.buffer,raw.byteOffset,count),f=new Float32Array(count);for(let i=0;i<count;i++)f[i]=GMLDType.halfBitsToFloat(u[i]);return new Tensor(f,record.shape,true,record.name,runner,{dtype:'f16'});}values=new Float32Array(raw.buffer.slice(raw.byteOffset,raw.byteOffset+raw.byteLength));return new Tensor(values,record.shape,true,record.name,runner,{dtype:'f32'});},
+            restore(buffer,runner,parserRef){const decoded=this.decode(buffer),meta=decoded.header.model;if(meta.kind==='char_lm')return new GMLCharLanguageModel(meta.trainingText,parserRef,meta.context);if(meta.kind==='custom'){if(!parserRef)throw new GMLValidationError('Restoring a custom architecture needs a GML parser so its bundled functions can be registered.');const processed=parserRef.preprocessCode(String(decoded.header.source||'').split('\n'));for(const item of processed)if(item.type==='function')parserRef.defineFunction(item.name,item.args,item.body);const scope=new GMLArchitectureScope(meta.architecture,parserRef,runner);for(const rec of decoded.header.tensors){const t=this._decodeTensor(rec,decoded.tensorBytes(rec.name),runner);scope.params.set(rec.name,t);parserRef.trackTensor(t);}return new GMLCustomArchitectureModel(scope,meta.functionName);}if(meta.kind!=='mlp')return {source:decoded.header.source,metadata:meta,tensors:decoded.header.tensors.map(r=>({record:r,bytes:decoded.tensorBytes(r.name)}))};const model=new GMLModel(meta.layerSizes,meta.activation,runner,parserRef,meta.seed??1337);model.task=meta.task||'regression';model.inputEncoding=meta.inputEncoding||null;const byName=new Map(decoded.header.tensors.map(r=>[r.name,r]));for(let i=0;i<model.layers.length;i++){for(const [key,slot] of [[`layer${i+1}.weight`,'W'],[`layer${i+1}.bias`,'B']]){const rec=byName.get(key);if(!rec)throw new Error(`Missing ${key} in model bundle.`);model.layers[i][slot].destroy();model.layers[i][slot]=this._decodeTensor(rec,decoded.tensorBytes(key),runner);}}if(meta.preprocessor?.enabled){model.preprocessor={enabled:true,mean:new Tensor(meta.preprocessor.mean,[1,meta.preprocessor.mean.length],false,'restore_mean',runner),scale:new Tensor(meta.preprocessor.scale,[1,meta.preprocessor.scale.length],false,'restore_scale',runner)};}model.targetPreprocessor=meta.targetPreprocessor||null;return model;},
+            download(model,filename='model.gmlm',source=''){const name=String(filename||'model.gmlm').endsWith('.gmlm')?String(filename):`${filename}.gmlm`,buffer=this.encode(model,source),url=URL.createObjectURL(new Blob([buffer],{type:'application/octet-stream'})),a=document.createElement('a');a.href=url;a.download=name;a.style.display='none';document.body.appendChild(a);a.click();a.remove();setTimeout(()=>URL.revokeObjectURL(url),1000);return `Saved ${name} (${formatBytes(buffer.byteLength)})`;}
+        };
+        if(typeof window!=='undefined')window.GMLModelBundle=GMLModelBundle;
+
         class GMLModel {
             constructor(layerSizes, activation, runner, parserRef, seed = 1337) {
                 GMLValidate.shape(layerSizes, 'mlp layer sizes', { maxRank: 64 });
@@ -4088,8 +4267,9 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                 this._adamState = new Map();
                 this._adamStep = 0;
                 this._scheduler = new GMLCooperativeScheduler(8);
-                this.__gmlProperties = new Set(['inputSize', 'outputSize', 'activation', 'task', 'history', 'plan', 'inputEncoding']);
-                this.__gmlMethods = new Set(['fit', 'predict', 'evaluate', 'summary', 'parameters', 'explain']);
+                this.executionDevice='gpu';
+                this.__gmlProperties = new Set(['inputSize', 'outputSize', 'activation', 'task', 'history', 'plan', 'inputEncoding','dtype','device']);
+                this.__gmlMethods = new Set(['fit', 'predict', 'evaluate', 'summary', 'parameters', 'explain','to','cpu','gpu','f32','f16','i8','save']);
 
                 let state = (seed >>> 0) || 1;
                 const random = () => {
@@ -4120,6 +4300,16 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
             }
 
             parameters() { return this.layers.flatMap(layer => [layer.W, layer.B]); }
+            _stateTensors(){const out=this.parameters().slice();if(this.preprocessor?.enabled){if(this.preprocessor.mean instanceof Tensor)out.push(this.preprocessor.mean);if(this.preprocessor.scale instanceof Tensor)out.push(this.preprocessor.scale);}return out;}
+            get dtype(){return this.parameters()[0]?.dtype||'f32';}
+            get device(){return this.executionDevice;}
+            cpu(){this.executionDevice='cpu';this._stateTensors().forEach(p=>p.cpu());return this;}
+            gpu(){this.executionDevice='gpu';this._stateTensors().forEach(p=>p.gpu());return this;}
+            f32(){this._stateTensors().forEach(p=>p.f32());return this;}
+            f16(){this._stateTensors().forEach(p=>p.f16());return this;}
+            i8(){this.parameters().forEach(p=>p.i8());return this;}
+            to(target){const t=String(target??'').toLowerCase();if(t==='cpu')return this.cpu();if(t==='gpu'||t==='webgl')return this.gpu();if(t==='f32')return this.f32();if(t==='f16')return this.f16();if(t==='i8'||t==='int8')return this.i8();throw new GMLValidationError(`Unknown model target '${target}'.`,`Use cpu, gpu, f32, f16, or i8.`);}
+            save(filename='model.gmlm'){return GMLModelBundle.download(this,filename,typeof getEditorSource==='function'?getEditorSource():'');}
 
             summary() {
                 const params = this.parameters().reduce((sum, p) => sum + p.size, 0);
@@ -4141,7 +4331,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                     `  tensors: [`
                 ];
                 this.layers.forEach((layer,index)=>{
-                    lines.push(`    { weight: Tensor(shape=[${layer.W.shape.join(', ')}], device=${layer.W.texture?'gpu':'cpu'}), bias: Tensor(shape=[${layer.B.shape.join(', ')}], device=${layer.B.texture?'gpu':'cpu'}) }${index===this.layers.length-1?'':','}`);
+                    lines.push(`    { weight: Tensor(shape=[${layer.W.shape.join(', ')}], dtype=${layer.W.dtype}, device=${layer.W.device}), bias: Tensor(shape=[${layer.B.shape.join(', ')}], dtype=${layer.B.dtype}, device=${layer.B.device}) }${index===this.layers.length-1?'':','}`);
                 });
                 lines.push(`  ]${this.plan?',':''}`);
                 if(this.plan)lines.push(`  plan: ${JSON.stringify(this.plan.summary())}`);
@@ -4230,6 +4420,12 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                 GMLValidate.tensor(input, 'model input', { runner: this.runner, requireData: true });
                 if (input.shape.length !== 2) throw new GMLValidationError(`Model input must be 2D [batch, features], got [${input.shape}].`, `Expected feature width ${this.inputSize}.`);
                 if (input.shape[1] !== this.inputSize) throw new GMLValidationError(`Model expects ${this.inputSize} input features, got ${input.shape[1]}.`);
+                if(this.executionDevice==='cpu'){
+                    let value=input;if(value.device!=='cpu')value.cpu();
+                    if(this.preprocessor?.enabled){const src=value.numericData(),mean=this.preprocessor.mean.numericData(),scale=this.preprocessor.scale.numericData(),out=new Float32Array(src.length),cols=value.shape[1];for(let i=0;i<src.length;i++)out[i]=(src[i]-mean[i%cols])/scale[i%cols];value=new Tensor(out,value.shape.slice(),false,'cpu_preprocess',this.runner,{device:'cpu'});}
+                    for(let i=0;i<this.layers.length;i++){const layer=this.layers[i];value=GMLCpu.matmul(value,layer.W,layer.B);if(i<this.layers.length-1)value=GMLCpu.activate(value,this.activation);}
+                    return value;
+                }
                 let value = this._preprocess(input);
                 for (let i = 0; i < this.layers.length; i++) {
                     const layer = this.layers[i];
@@ -4620,6 +4816,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
             }
 
             async fit(xValue, yValue, epochs = 100, learningRate = 0.01, batchSize = 64) {
+                if(this.executionDevice==='cpu')throw new GMLValidationError('This model is currently on CPU. CPU inference is supported; training remains GPU-optimized in v0.3.','Call Model.gpu() before fit(), then Model.cpu() afterward if you want CPU inference.');
                 GMLValidate.epochs(epochs); GMLValidate.learningRate(learningRate); GMLValidate.batchSize(batchSize);
                 const X = this.parser.coerceValueToTensor(xValue, 'fit X');
                 const Y = this.parser.coerceValueToTensor(yValue, 'fit Y');
@@ -4667,7 +4864,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                         const tp = this.targetPreprocessor?.enabled ? this.targetPreprocessor : { mean: 0, scale: 1 };
                         for (let i = 0; i < z.length; i++) outputData[i] = z[i] * tp.scale + tp.mean;
                     }
-                    const result = new Tensor(outputData, logits.shape.slice(), false, 'prediction', this.runner);
+                    const result = new Tensor(outputData, logits.shape.slice(), false, 'prediction', this.runner,{device:this.executionDevice==='cpu'?'cpu':'gpu',dtype:'f32'});
                     this._cleanupGraph(graph, new Set([X, ...params]));
                     return this.parser.trackTensor(result);
                 } finally { params.forEach((p, i) => p.requires_grad = oldRequiresGrad[i]); }
@@ -4867,13 +5064,20 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                 if(!scope.parser.functions.has(functionName))throw new GMLValidationError(`Function '${functionName}' is not defined.`);
                 this.scope=scope;this.functionName=functionName;this.task='custom';
                 this.__gmlProperties=new Set(['task']);
-                this.__gmlMethods=new Set(['predict','parameters','zero_grad','step','summary','explain']);
+                this.__gmlMethods=new Set(['predict','parameters','zero_grad','step','summary','explain','to','cpu','gpu','f32','f16','i8','save']);
             }
             async predict(x){
                 const input=this.scope.parser.coerceValueToTensor(x,'custom model input');
                 return await this.scope.run(this.functionName,input);
             }
             parameters(){return this.scope.parameters();}
+            cpu(){this.parameters().forEach(p=>p.cpu());return this;}
+            gpu(){this.parameters().forEach(p=>p.gpu());return this;}
+            f32(){this.parameters().forEach(p=>p.f32());return this;}
+            f16(){this.parameters().forEach(p=>p.f16());return this;}
+            i8(){this.parameters().forEach(p=>p.i8());return this;}
+            to(target){const t=String(target??'').toLowerCase();if(t==='cpu')return this.cpu();if(t==='gpu'||t==='webgl')return this.gpu();if(t==='f32')return this.f32();if(t==='f16')return this.f16();if(t==='i8'||t==='int8')return this.i8();throw new GMLValidationError(`Unknown model target '${target}'.`);}
+            save(filename='model.gmlm'){return GMLModelBundle.download(this,filename,typeof getEditorSource==='function'?getEditorSource():'');}
             zero_grad(){this.scope.zero_grad();return this;}
             async step(lr=0.001){await this.scope.step(lr);return this;}
             summary(){return `CustomModel(${this.scope.name}:${this.functionName}, parameters=${this.parameters().length})`;}
@@ -5292,7 +5496,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                     const media=value._media?`, media=${JSON.stringify(value._media)}`:(value._mediaTokens?`, tokens=${JSON.stringify(value._mediaTokens)}`:'');
                     return `Tensor { shape: [${value.shape.join(', ')}], size: ${value.size}, device: ${device}, requires_grad: ${Boolean(value.requires_grad)}${media}${sample} }`;
                 }
-                if(value instanceof GMLModel || value instanceof GMLCustomArchitectureModel || value instanceof GMLArchitectureScope || value instanceof GMLMetrics || value instanceof GMLTaskPlan || value instanceof PlotSeries || value instanceof PlotHistory || value instanceof VirtualFileHandle) return value.toString();
+                if(value instanceof GMLModel || value instanceof GMLCustomArchitectureModel || value instanceof GMLCharLanguageModel || value instanceof GMLArchitectureScope || value instanceof GMLMetrics || value instanceof GMLTaskPlan || value instanceof PlotSeries || value instanceof PlotHistory || value instanceof VirtualFileHandle) return value.toString();
                 if(value===null)return 'null';if(value===undefined)return 'undefined';
                 if(typeof value==='string')return JSON.stringify(value);if(typeof value==='number')return formatGmlNumber(value);if(typeof value==='boolean'||typeof value==='bigint')return String(value);if(typeof value==='function')return `[Function ${value.name||'anonymous'}]`;
                 if(Array.isArray(value)){
@@ -5981,7 +6185,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                     type: ['Type inspection', 'type(value)', 'Returns a short type name such as int, float, string, array, tensor, or model.'],
                     tensor: ['Tensor', 'tensor(data)', 'Creates a tensor from numeric data.'],
                     param: ['Trainable tensor', 'param(data)', 'Creates a trainable tensor.'],
-                    learn: ['Learning', 'model = learn(X, Y)', 'Builds and trains a model from examples and targets.'],
+                    learn: ['Learning', 'model = learn(data) · model = learn(X, Y)', 'Infers a compact model from a text sequence or from supervised examples and targets.'],
                     plan: ['Learning plan', 'plan(X, Y)', 'Shows the plan GML would use for a learning task.'],
                     classify: ['Classification', 'classify(model, X, labels?)', 'Returns predicted class IDs or label names.'],
                     predict: ['Prediction', 'predict(model, X)', 'Runs a model and returns its outputs.'],
@@ -5996,6 +6200,14 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                     fit: ['Training', 'fit(model, X, Y, ...)', 'Trains an explicitly created model.'],
                     matmul: ['Matrix multiplication', 'matmul(A, B)', 'Multiplies two rank-2 tensors.'],
                     linear: ['Linear layer', 'linear(X, outputSize) · linear(X, W, B)', 'Projects the last feature dimension; architecture contexts can own and reuse parameters automatically.'],
+                    generate: ['Generate text', 'generate(Model, prompt, length?) · Model.generate(prompt, length?)', 'Continues a character language model from a prompt.'],
+                    save: ['Save model', 'save(Model, "model.gmlm") · Model.save("model.gmlm")', 'Downloads one self-contained bundle containing source, model metadata, and learned state or weights.'],
+                    to: ['Move or cast', 'Tensor.to("gpu") · Tensor.to("cpu") · Tensor.to("f16")', 'Moves a tensor between CPU/GPU execution or changes its dtype.'],
+                    cpu: ['CPU execution', 'Tensor.cpu() · Model.cpu()', 'Moves state to CPU execution for supported core operations and inference.'],
+                    gpu: ['GPU execution', 'Tensor.gpu() · Model.gpu()', 'Moves state to GPU execution.'],
+                    f16: ['Float16', 'Tensor.f16() · Model.f16()', 'Uses 16-bit floating-point storage on supported WebGL2 devices.'],
+                    f32: ['Float32', 'Tensor.f32() · Model.f32()', 'Uses 32-bit floating-point values.'],
+                    i8: ['Int8', 'Tensor.i8() · Model.i8()', 'Quantizes values to signed 8-bit storage; WebGL math promotes when native int8 compute is unavailable.'],
                     sum: ['Sum', 'sum(x, axis?)', 'Adds tensor values, optionally along an axis.'],
                     mean: ['Mean', 'mean(x, axis?)', 'Averages tensor values, optionally along an axis.'],
                     relu: ['ReLU', 'relu(x)', 'Applies max(0, x).'],
@@ -6551,6 +6763,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
 
             defineFunction(name, argNames, processedBody) {
                 if (this.functions.has(name)) console.warn(`Redefining func ${name}`);
+                if(this.devMode&&this.getBuiltinNames().includes(name))this.log(`User function '${name}' shadows a builtin for this script.`);
                 this.functions.set(name, { args: argNames, body: processedBody });
                 this.log(`   Defined function ${name}(${argNames.join(', ')})`);
             }
@@ -7084,7 +7297,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                     'int','float','string','bool','type','image','audio','video','patchify','frame',
                     'tensor','param','zeros','ones','add','sub','mul','div','square','abs','negate','transpose','permute','matmul','batched_matmul','linear',
                     'relu','relu6','leaky_relu','elu','selu','gelu','silu','swish','swiglu','geglu','softplus','mish','sigmoid','tanh','softmax','log_softmax','layer_norm','rms_norm','l2_norm','rope','causal_mask','window_mask','attention','shift','causal_conv1d','affine_scan','repeat_interleave','concat','slice','one_hot','embedding','lerp','dropout','exp','log','sqrt','sum','mean','normalize','flatten','reshape',
-                    'mlp','architecture','plan','learn','fit','predict','evaluate','classify','mse','binary_cross_entropy','bce','cross_entropy',
+                    'mlp','architecture','plan','learn','fit','predict','evaluate','classify','generate','save','mse','binary_cross_entropy','bce','cross_entropy',
                     'assert','assert_shape','assert_finite','describe','series','history','plot','dots','progress',
                     'watch','write','append','read','files','remove','emit','clear_live','grid','table','md','markdown','graphemes','text_length',
                     'print','print_grad','has_grad','step','zero_grad'
@@ -7180,7 +7393,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                         if (evArgs.length !== 1) throw new GMLValidationError('type(value) expects exactly one value.');
                         const value = evArgs[0];
                         if (value instanceof Tensor) return 'tensor';
-                        if (value instanceof GMLModel || value instanceof GMLCustomArchitectureModel) return 'model';
+                        if (value instanceof GMLModel || value instanceof GMLCustomArchitectureModel || value instanceof GMLCharLanguageModel) return 'model';
                         if (value instanceof GMLArchitectureScope) return 'architecture';
                         if (value instanceof GMLMetrics) return 'metrics';
                         if (value instanceof GMLTaskPlan || value?.kind === 'semantic_ml_plan') return 'plan';
@@ -7272,7 +7485,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                         if (evArgs.length !== 2) throw Error("matmul(a, b)");
                         const a = tensorArg(evArgs[0], 'matmul arg 1');
                         const b = tensorArg(evArgs[1], 'matmul arg 2');
-                        return this.trackTensor(MatMul.apply(ctx, a, b));
+                        return this.trackTensor(a.matmul(b));
                     }
                     case 'linear': {
                         if(evArgs.length===2 && typeof evArgs[1]==='number'){
@@ -7285,7 +7498,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                         const a=tensorArg(evArgs[0],'linear input');
                         const w=tensorArg(evArgs[1],'linear weight');
                         const bias=tensorArg(evArgs[2],'linear bias');
-                        if(a.shape.length===2)return this.trackTensor(Linear.apply({runner:this.runner,inputs:[a,w,bias],disableFusion:true,architecture:GMLArchitectureRuntime.current()?.family||null},a,w,bias));
+                        if(a.shape.length===2){if(a.device==='cpu'&&w.device==='cpu'&&bias.device==='cpu'&&!a.requires_grad&&!w.requires_grad&&!bias.requires_grad)return this.trackTensor(GMLCpu.matmul(a,w,bias));return this.trackTensor(Linear.apply({runner:this.runner,inputs:[a,w,bias],disableFusion:true,architecture:GMLArchitectureRuntime.current()?.family||null},a,w,bias));}
                         if(a.shape.length===3){const inFeatures=a.shape[2];if(w.shape.length!==2||w.shape[0]!==inFeatures)throw new GMLValidationError(`linear weight must be [${inFeatures}, out_features] for input [${a.shape}].`);const rows=a.size/inFeatures,flat=this.trackTensor(Reshape.apply({runner:this.runner,inputs:[a]},a,[rows,inFeatures])),projected=this.trackTensor(Linear.apply({runner:this.runner,inputs:[flat,w,bias],disableFusion:true,architecture:GMLArchitectureRuntime.current()?.family||null},flat,w,bias));return this.trackTensor(Reshape.apply({runner:this.runner,inputs:[projected]},projected,[a.shape[0],a.shape[1],w.shape[1]]));}
                         throw new GMLValidationError(`linear() expects rank-2 or rank-3 input, got [${a.shape}].`);
                     }
@@ -7411,8 +7624,9 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                         return GMLTaskPlanner.create(X, Y, this.runner, evArgs[2] ?? 'balanced');
                     }
                     case 'learn': {
+                        if(evArgs.length===1&&typeof evArgs[0]==='string')return new GMLCharLanguageModel(evArgs[0],this);
                         if (evArgs.length < 2 || evArgs.length > 5) {
-                            throw new GMLValidationError("learn(X, Y, intent?)", "Usually just write learn(X, Y). Optional intent: 'fast', 'accurate', 'tiny', or 'research'. Legacy hidden/epoch/lr overrides still work.");
+                            throw new GMLValidationError("learn(data) for a text sequence, or learn(X, Y, intent?)", "GML infers a compact character language model from one string; supervised data uses learn(X, Y).");
                         }
                         const rawX = evArgs[0];
                         const stringEncoded = isGmlStringDataset(rawX);
@@ -7450,6 +7664,14 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
                         await model._fitWithPlan(X, Y, semanticPlan);
                         return model;
                     }
+                    case 'generate': {
+                        if(evArgs.length<2||evArgs.length>4)throw new GMLValidationError('generate(model, prompt, length?, temperature?)');
+                        const [model,prompt,length=32,temperature=0]=evArgs;if(!(model instanceof GMLCharLanguageModel))throw new GMLValidationError('generate() currently expects a language model returned by learn(text).');return model.generate(prompt,length,temperature);
+                    }
+                    case 'save': {
+                        if(evArgs.length<1||evArgs.length>2)throw new GMLValidationError('save(model, filename?)');
+                        const filename=evArgs[1]??'model.gmlm';return GMLModelBundle.download(evArgs[0],filename,typeof getEditorSource==='function'?getEditorSource():'');
+                    }
                     case 'mse': {
                         if (evArgs.length !== 2) throw new GMLValidationError("mse(prediction, target)");
                         const a = tensorArg(evArgs[0], 'mse prediction');
@@ -7825,6 +8047,19 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
         }
 
         // --- Syntax Highlighting Globals & Functions ---
+        const GML_CORE_PRIMITIVES = Object.freeze({
+            construct:['tensor','param'],
+            elementwise:['add','sub','mul','div','exp','log','sqrt'],
+            contract:['matmul'],
+            reduce:['sum','mean'],
+            shape:['reshape','permute','slice','concat'],
+            window:['causal_conv1d','frame','patchify'],
+            scan:['affine_scan'],
+            convert:['to','f32','f16','i8','cpu','gpu'],
+            compose:['function','architecture']
+        });
+        if(typeof window!=='undefined')window.GML_CORE_PRIMITIVES=GML_CORE_PRIMITIVES;
+
         const _syntaxHighlightingElements = {
             codeInput: null,
             highlightingArea: null,
@@ -7848,7 +8083,7 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
             runBenchmarkButton: null
         };
         const _appState = {
-            selectedPreset: 'emoji',
+            selectedPreset: 'showcase',
             isBusy: false
         };
         const GML_WORKSPACE_KEY = 'gml.v0.3.workspace';
@@ -7889,8 +8124,19 @@ precision highp float;precision highp int;precision highp sampler2D;uniform samp
         function restoreWorkspace() {
             const storage=getWorkspaceStorage();if(!storage)return false;
             let state;
-            try{const raw=storage.getItem(GML_WORKSPACE_KEY);if(!raw)return false;state=JSON.parse(raw);}catch(_){return false;}
-            if(!state||typeof state.source!=='string')return false;
+            try{
+                const raw=storage.getItem(GML_WORKSPACE_KEY);
+                if(!raw||!String(raw).trim())return false;
+                state=JSON.parse(raw);
+            }catch(_){
+                try{storage.removeItem(GML_WORKSPACE_KEY);}catch(__){}
+                return false;
+            }
+            // A blank saved editor is equivalent to no workspace: boot into the showcase.
+            if(!state||typeof state.source!=='string'||!state.source.trim()){
+                try{storage.removeItem(GML_WORKSPACE_KEY);}catch(_){}
+                return false;
+            }
             const input=_syntaxHighlightingElements.codeInput;if(!input)return false;
             _workspaceRestoring=true;
             try{
@@ -8047,79 +8293,28 @@ assert_shape(Predictions, 4, 1)`
             },
             showcase: {
                 label: 'Showcase',
-                description: 'Intent-first ML, inferred tensors, autograd, and GPU-resident training.',
-                code: `@dev
-# Arithmetic
-NumA = 5
-NumB = 10
-NumC = 2
-Result1 = NumA + NumB * NumC
-Result2 = (NumA + NumB) * NumC
-print "Result1:", Result1
-print "Result2:", Result2
-
-# Tensor ops with inferred shapes
-T1 = tensor([[1., 2.], [3., 4.]])
-T2 = tensor([[10., 20.], [30., 40.]])
-T3 = T1 + T2
-T4 = T1 * NumA
-print T3
-print T4
-
-# Autograd
-X = param([1., 2., 3.])
-Y = X * 2.0
-Z = sum(Y)
-Z.backward()
-print_grad(X)
-
-# Intent-first ML: task + implementation are inferred
-Features = [[0.,0.], [0.,1.], [1.,0.], [1.,1.]]
-Labels = [[0.], [1.], [1.], [1.]]
-Idea = plan(Features, Labels)
-print Idea
-AutoModel = learn(Features, Labels)
-print AutoModel.explain()
-print AutoModel.predict(Features)
-
-# Low-level escape hatch
-# Manual forward pass
-function linear(input_tensor, weights, bias) {
-    mm_result = matmul(input_tensor, weights)
-    output = mm_result + bias
-    return output
-}
+                description: 'Train a tiny character language model, generate text, and optionally export it.',
+                code: `# A complete first GML program: train from one sequence.
+Text = "Hello world from gml!"
 
-function softmax_1d(logits_vector) {
-    exp_logits = exp(logits_vector)
-    return exp_logits / sum(exp_logits)
-}
+# GML infers a compact character model from the sequence.
+LanguageModel = learn(Text)
 
-function cross_entropy_1d(probabilities, target_one_hot) {
-    return negate(sum(target_one_hot * log(probabilities)))
+# User functions stay ordinary and reusable.
+function complete(model, prompt, characters) {
+    return model.generate(prompt, characters)
 }
 
-W = param([[0.1, 0.2, 0.3], [-0.1, 0.5, 0.2]])
-B = param([[0.01, -0.02, 0.03]])
-Input = [[0.5, -0.5]]
-Target = [[0., 1., 0.]]
-Loss = cross_entropy_1d(softmax_1d(linear(Input, W, B)), Target)
-print "Loss:", Loss
-Loss.backward()
-step(0.1, W, B)
-print "Updated W:", W
-print "Updated B:", B
-
-# Normalize / reshape
-Flat = param([1., 2., 3., 4., 5., 6.])
-Grid = reshape(Flat, 2, 3)
-NormInput = param([10., 20., 30., 40.])
-NormOut = normalize(NormInput)
-NormLoss = sum(NormOut)
-NormLoss.backward()
-print Grid
-print NormOut
-print_grad(NormInput)`
+print LanguageModel
+print "Prompt: Hello "
+print "Prediction:", complete(LanguageModel, "Hello ", 15)
+
+# Models can move/cast with the same small interface used by tensors:
+# SomeTensor = tensor([[1., 2.], [3., 4.]]).f16().gpu()
+# SomeTensor = SomeTensor.cpu()
+
+# Uncomment to download one self-contained file containing source + model state:
+# LanguageModel.save("hello-world.gmlm")`
             },
             syntax: {
                 label: 'Syntax Edge Cases',
@@ -9199,6 +9394,30 @@ Responsive = learn(X, Y, [8], 10, 0.03)`);
                     return 'binary_cross_entropy() and cross_entropy() execute forward/backward without GPU→CPU readback.';
                 }
             },
+            {
+                name:'User Function Highlight Shadowing',
+                async run(){const html=highlightSyntax('function linear(x) {\n  return linear(x, 2)\n}\nsoftmax(x)');if(/syntax-builtin[^>]*>linear</.test(html))throw new Error('User-defined linear() still receives builtin coloring.');if(!/syntax-builtin[^>]*>softmax</.test(html))throw new Error('Normal builtin coloring was lost.');return 'User-defined function names visually override builtin coloring without changing unrelated builtins.';}
+            },
+            {
+                name:'DType + Device Contract',
+                async run(){const x=new Tensor(new Float32Array([0.1,-1.2,3.4,5.6]),[2,2],false,'dtype_probe',webglRunner,{device:'cpu'});if(x.dtype!=='f32'||x.device!=='cpu')throw new Error('Initial dtype/device mismatch.');x.f16();if(x.dtype!=='f16')throw new Error('f16 cast failed.');x.gpu();if(x.device!=='gpu')throw new Error('gpu move failed.');x.cpu().i8();if(x.dtype!=='i8'||x.device!=='cpu'||!x.quantization)throw new Error('int8 quantization contract failed.');x.f32();if(x.dtype!=='f32')throw new Error('f32 restoration failed.');x.destroy();return 'Tensor .f16/.f32/.i8 and .cpu/.gpu transitions preserve explicit dtype/device state.';}
+            },
+            {
+                name:'Self-Contained Model Bundle',
+                async run(){const m=new GMLModel([2,2],'relu',webglRunner,parser,1337);const buf=GMLModelBundle.encode(m,'X = 1');const decoded=GMLModelBundle.decode(buf);if(decoded.header.format!=='gml-model'||decoded.header.source!=='X = 1'||decoded.header.tensors.length!==2)throw new Error('Model bundle metadata is incomplete.');for(const t of decoded.header.tensors)if(decoded.tensorBytes(t.name).byteLength!==t.length)throw new Error(`Tensor payload mismatch for ${t.name}.`);const restored=GMLModelBundle.restore(buf,webglRunner,parser);if(!(restored instanceof GMLModel)||restored.layerSizes.join(',')!=='2,2')throw new Error('Model restore failed.');m.parameters().forEach(p=>p.destroy());restored.parameters().forEach(p=>p.destroy());return 'One binary bundle contains source, model metadata, dtype/shape records, all parameter bytes, and can reconstruct the model.';}
+            },
+            {
+                name:'Custom Architecture Bundle Restore',
+                async run(){const source='function portable_block(x) {\n    return linear(x, 3)\n}';const items=parser.preprocessCode(source.split('\n'));for(const item of items)if(item.type==='function')parser.defineFunction(item.name,item.args,item.body);const scope=new GMLArchitectureScope('portable',parser,webglRunner),x=new Tensor(new Float32Array([1,2]),[1,2],false,'portable_x',webglRunner);parser.trackTensor(x);await scope.run('portable_block',x);const model=scope.model('portable_block'),buf=GMLModelBundle.encode(model,source);const restored=GMLModelBundle.restore(buf,webglRunner,parser);if(!(restored instanceof GMLCustomArchitectureModel)||restored.parameters().length!==model.parameters().length)throw new Error('Custom model did not restore bundled functions/parameters.');restored.parameters().forEach(t=>t.destroy());model.parameters().forEach(t=>t.destroy());x.destroy();return 'Custom architecture bundles restore their source-defined block and named parameter tensors without executing unrelated source statements.';}
+            },
+            {
+                name:'Serialized DType Roundtrip',
+                async run(){const m=new GMLModel([2,2],'relu',webglRunner,parser,1337);m.f16();const buf16=GMLModelBundle.encode(m,'');const r16=GMLModelBundle.restore(buf16,webglRunner,parser);if(r16.dtype!=='f16')throw new Error(`f16 bundle restored as ${r16.dtype}.`);m.i8();const buf8=GMLModelBundle.encode(m,'');const d8=GMLModelBundle.decode(buf8);if(!d8.header.tensors.every(t=>t.dtype==='i8'&&t.quantization?.scale>0))throw new Error('int8 bundle omitted quantization metadata.');const r8=GMLModelBundle.restore(buf8,webglRunner,parser);if(r8.dtype!=='i8'||r8.parameters().some(t=>t.requires_grad))throw new Error('int8 restore contract failed.');m.parameters().forEach(p=>p.destroy());r16.parameters().forEach(p=>p.destroy());r8.parameters().forEach(p=>p.destroy());return 'f16 and int8 dtypes survive model serialization; int8 stores explicit quantization metadata.';}
+            },
+            {
+                name:'Character LM Showcase Contract',
+                async run(){const lm=new GMLCharLanguageModel('Hello world from gml!',parser);const out=lm.generate('Hello ',15);if(out!=='Hello world from gml!')throw new Error(`Char LM continuation mismatch: ${out}`);if(lm.context>8||lm.vocab.length<5)throw new Error('Char LM compiler produced an invalid context/vocabulary.');return `learn(text) deterministically continues the showcase sequence with context=${lm.context}.`;}
+            },
             {
                 name:'Public UI Hides Internal Benchmarking',
                 async run(){if(document.getElementById('runBenchmarkButton')||document.getElementById('benchmarkSummary'))throw new Error('Internal benchmark controls leaked into the user UI.');const visible=document.body.innerText;if(/TensorFlow|TF\.js|release gate/i.test(visible))throw new Error('Internal benchmark/release wording leaked into visible UI.');return 'Internal performance/release tooling remains callable programmatically but is absent from the normal product UI.';}
@@ -9210,8 +9429,8 @@ Responsive = learn(X, Y, [8], 10, 0.03)`);
             { type: 'string', regex: /^"(?:\\.|[^"\\])*"/ },
             { type: 'directive', regex: /^@(dev|help|quiet)\b/ },
             { type: 'keyword', regex: /^\b(function|return|if|else|for|while|true|false|null)\b/ }, // Added null
-            { type: 'builtin', regex: /^\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\.\s*(grad|backward|relu|relu6|leaky_relu|elu|selu|gelu|silu|swish|swiglu|geglu|softplus|mish|sigmoid|tanh|softmax|log_softmax|layer_norm|rms_norm|l2_norm|rope|causal_mask|window_mask|shift|causal_conv1d|affine_scan|repeat_interleave|patchify|frame|permute|batched_matmul|slice|concat|dropout|sum|mean|square|abs|exp|log|sqrt|transpose|reshape|zero_grad|fit|predict|evaluate|classify|summary|parameters|explain|run|repeat|model|step|wait|text|animation|anim|on|once|off|emit|when|done|error|clear|start|update|title|json|lines)\b/ },
-            { type: 'builtin', regex: /^\b(seed|random|int|float|string|bool|type|image|audio|video|patchify|frame|tensor|param|mlp|architecture|plan|learn|fit|predict|evaluate|classify|mse|binary_cross_entropy|bce|cross_entropy|assert|assert_shape|assert_finite|describe|add|sub|mul|div|square|abs|negate|transpose|permute|matmul|batched_matmul|linear|relu|relu6|leaky_relu|elu|selu|gelu|silu|swish|swiglu|geglu|softplus|mish|sigmoid|tanh|softmax|log_softmax|layer_norm|rms_norm|l2_norm|rope|causal_mask|window_mask|attention|shift|causal_conv1d|affine_scan|repeat_interleave|concat|slice|one_hot|embedding|lerp|dropout|exp|log|sqrt|sum|mean|normalize|flatten|reshape|zeros|ones|series|history|plot|dots|progress|watch|emit|clear_live|write|append|read|files|remove|grid|table|md|markdown|graphemes|text_length|step|zero_grad|print|print_grad|has_grad|_clear_grad|_set_grad)\b/ },
+            { type: 'builtin', regex: /^\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\.\s*(grad|backward|relu|relu6|leaky_relu|elu|selu|gelu|silu|swish|swiglu|geglu|softplus|mish|sigmoid|tanh|softmax|log_softmax|layer_norm|rms_norm|l2_norm|rope|causal_mask|window_mask|shift|causal_conv1d|affine_scan|repeat_interleave|patchify|frame|permute|batched_matmul|slice|concat|dropout|sum|mean|square|abs|exp|log|sqrt|transpose|reshape|zero_grad|fit|predict|evaluate|classify|summary|parameters|explain|generate|save|to|cpu|gpu|f32|f16|i8|run|repeat|model|step|wait|text|animation|anim|on|once|off|emit|when|done|error|clear|start|update|title|json|lines)\b/ },
+            { type: 'builtin', regex: /^\b(seed|random|int|float|string|bool|type|image|audio|video|patchify|frame|tensor|param|mlp|architecture|plan|learn|fit|predict|evaluate|classify|generate|save|mse|binary_cross_entropy|bce|cross_entropy|assert|assert_shape|assert_finite|describe|add|sub|mul|div|square|abs|negate|transpose|permute|matmul|batched_matmul|linear|relu|relu6|leaky_relu|elu|selu|gelu|silu|swish|swiglu|geglu|softplus|mish|sigmoid|tanh|softmax|log_softmax|layer_norm|rms_norm|l2_norm|rope|causal_mask|window_mask|attention|shift|causal_conv1d|affine_scan|repeat_interleave|concat|slice|one_hot|embedding|lerp|dropout|exp|log|sqrt|sum|mean|normalize|flatten|reshape|zeros|ones|series|history|plot|dots|progress|watch|emit|clear_live|write|append|read|files|remove|grid|table|md|markdown|graphemes|text_length|step|zero_grad|print|print_grad|has_grad|_clear_grad|_set_grad)\b/ },
             { type: 'number', regex: /^(?:\d+\.\d*|\.\d+|\d+)(?:[eE][+\-]?\d+)?\b/ },
             { type: 'operator', regex: /^(==|<=|>=|!=|&&|\|\|)/ },
             { type: 'operator', regex: /^[+\-*/=<>^]/ },
@@ -11207,6 +11426,8 @@ Responsive = learn(X, Y, [8], 10, 0.03)`);
         }
 
         function highlightSyntax(code) {
+            const userFunctions=new Set();
+            for(const match of String(code).matchAll(/\bfunction\s+([A-Za-z_$][\w$]*)\s*\(/g))userFunctions.add(match[1]);
             let remainingCode = code;
             let htmlOutput = '';
 
@@ -11221,7 +11442,9 @@ Responsive = learn(X, Y, [8], 10, 0.03)`);
                         if (tokenDef.type === 'whitespace' || tokenDef.type === 'unknown') {
                             htmlOutput += escapeHtml(tokenValue);
                         } else {
-                            htmlOutput += `<span class="syntax-${tokenDef.type}">${escapeHtml(tokenValue)}</span>`;
+                            const bare=tokenValue.trim();
+                            const actualType=(tokenDef.type==='builtin'&&userFunctions.has(bare))?'identifier':tokenDef.type;
+                            htmlOutput += `<span class="syntax-${actualType}">${escapeHtml(tokenValue)}</span>`;
                         }
                         matched = true;
                         break;
@@ -11580,7 +11803,7 @@ Responsive = learn(X, Y, [8], 10, 0.03)`);
             const caretPos = codeInput.selectionDirection === 'backward' ? codeInput.selectionStart : codeInput.selectionEnd;
 
             let left = paddingLeft;
-            let top = paddingTop + 8;
+            let top = paddingTop + 7;
             let width = caretSize;
             let height = caretSize;
             let borderRadius = '50%';
@@ -11602,7 +11825,7 @@ Responsive = learn(X, Y, [8], 10, 0.03)`);
 
                 const atLineEnd = caretPos === codeInput.value.length || codeInput.value.charAt(caretPos) === '\n';
                 if (atLineEnd) {
-                    top += 6;
+                    top += 5;
                 } else {
                     width = 2;
                     height = Math.max(14, Math.round(lineHeight * 0.95) - 2);