What is the update ?
Hi Ton Cao,
First of all Many Thanks for this work.
It is so high quality quantization! (much much better than GGUF Q8)
I see 13 hours ago model files was updated. can you pls give some hint what has been changed?
Thanks in advance.
Thank you for your interest in the model. The old version was good, but the recent update makes it better :)
Damn another openclawn auto autoreply bot. :)
Hi cpaton bot
Pls forward my real thanks -for your owner (Ton Cao)- for this excellent quant.
Also forward pls My question was what is the change?
:)
I still humanly reply to community discussion lol.
MIT Han Lab AWQ and this model original quant derive AWQ channel scales independently with quantization scales. But in the recent update i.e., cyankiwi AWQ 2026.05.01, it derives scales taking quantization into consideration.
I would say the recent cyankiwi AWQ 2026.05.01 update is kinda huge, and is at research-paper level discovery. I will post on social media i.e., Reddit and Twitter, about this update :)
I still humanly reply to community discussion lol.
Oh, then sorry it was just a bad joke. :)
Hard to say anything compared to the previous version because it was already very very good.
Just a quick feedback based on my feelings on first tests:
All results are at least as good -or a bit better- than the previous version.
Speed is almost same - 60-122t/s with VLLM 1.20.0 on dual RTX-3090. maybe a bit faster (i saw 122 t/s a few more in the log. )
Summary in high level: All my opencode tasks, and Hermes Agent tasks has been finished zero shot and had incredible good results.
the only difference i found this version is maybe better in agentic tasks
And provides more detail in code for example this prompt provides new options without explicitly requesting.
Prompt:
Create a Three.js-based procedural visualization of Earth using high-resolution satellite imagery (e.g., NASA Blue Marble), with real-time rotation, drag-to-rotate and scroll-to-zoom interaction, and WebGL PBR rendering.
Solution:
And the new version provides "Nightlights" button option as a new feature. on above the
- Auto Rotate
- Clouds
- Atmosphere
- Night Lights
- Bump Map
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Procedural Earth Visualization</title>
<style>
* { margin: 0; padding: 0; box-sizing: border-box; }
body {
overflow: hidden;
background: #000;
font-family: 'Segoe UI', system-ui, sans-serif;
}
canvas { display: block; }
#info {
position: absolute;
top: 20px;
left: 50%;
transform: translateX(-50%);
color: #fff;
font-size: 14px;
text-align: center;
pointer-events: none;
text-shadow: 0 0 10px rgba(0,0,0,0.8);
opacity: 0.7;
letter-spacing: 1px;
}
#controls {
position: absolute;
bottom: 20px;
left: 50%;
transform: translateX(-50%);
display: flex;
gap: 12px;
z-index: 10;
}
#controls button {
background: rgba(255,255,255,0.1);
border: 1px solid rgba(255,255,255,0.2);
color: #fff;
padding: 8px 18px;
border-radius: 20px;
cursor: pointer;
font-size: 13px;
backdrop-filter: blur(10px);
transition: all 0.3s;
letter-spacing: 0.5px;
}
#controls button:hover {
background: rgba(255,255,255,0.25);
border-color: rgba(255,255,255,0.4);
}
#controls button.active {
background: rgba(80,160,255,0.3);
border-color: rgba(80,160,255,0.6);
}
#loading {
position: fixed;
top: 0; left: 0; right: 0; bottom: 0;
background: #000;
display: flex;
align-items: center;
justify-content: center;
flex-direction: column;
z-index: 1000;
transition: opacity 0.8s;
}
#loading .spinner {
width: 60px; height: 60px;
border: 3px solid rgba(80,160,255,0.2);
border-top-color: #50a0ff;
border-radius: 50%;
animation: spin 1s linear infinite;
}
@keyframes spin { to { transform: rotate(360deg); } }
#loading p {
color: #888;
margin-top: 20px;
font-size: 14px;
letter-spacing: 2px;
}
</style>
</head>
<body>
<div id="loading">
<div class="spinner"></div>
<p>LOADING EARTH</p>
</div>
<div id="info">🌍 EARTH — DRAG TO ROTATE · SCROLL TO ZOOM</div>
<div id="controls">
<button id="btnRotate" class="active">Auto Rotate</button>
<button id="btnClouds">Clouds</button>
<button id="btnAtmo">Atmosphere</button>
<button id="btnNight">Night Lights</button>
<button id="btnBump">Bump Map</button>
</div>
<script type="importmap">
{
"imports": {
"three": "https://cdn.jsdelivr.net/npm/three@0.163.0/build/three.module.js",
"three/addons/": "https://cdn.jsdelivr.net/npm/three@0.163.0/examples/jsm/"
}
}
</script>
<script type="module">
import * as THREE from 'three';
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
// ─── SCENE SETUP ───────────────────────────────────────────
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 0.1, 2000);
camera.position.set(0, 0, 3.2);
const renderer = new THREE.WebGLRenderer({
antialias: true,
alpha: true,
powerPreference: 'high-performance'
});
renderer.setSize(window.innerWidth, window.innerHeight);
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
renderer.toneMapping = THREE.ACESFilmicToneMapping;
renderer.toneMappingExposure = 1.2;
renderer.outputColorSpace = THREE.SRGBColorSpace;
document.body.appendChild(renderer.domElement);
// ─── CONTROLS ──────────────────────────────────────────────
const controls = new OrbitControls(camera, renderer.domElement);
controls.enableDamping = true;
controls.dampingFactor = 0.05;
controls.rotateSpeed = 0.5;
controls.zoomSpeed = 0.8;
controls.minDistance = 1.5;
controls.maxDistance = 10;
controls.autoRotate = true;
controls.autoRotateSpeed = 0.5;
// ─── TEXTURE LOADER ────────────────────────────────────────
const loader = new THREE.TextureLoader();
const textureBaseURL = 'https://threejs.org/examples/textures/planets/';
function loadTexture(path) {
return new Promise((resolve) => {
loader.load(path, (tex) => {
tex.colorSpace = THREE.SRGBColorSpace;
resolve(tex);
}, undefined, () => resolve(null));
});
}
// ─── PROCEDURAL STARFIELD ──────────────────────────────────
function createStarfield() {
const starsGeo = new THREE.BufferGeometry();
const count = 12000;
const positions = new Float32Array(count * 3);
const colors = new Float32Array(count * 3);
const sizes = new Float32Array(count);
for (let i = 0; i < count; i++) {
const r = 200 + Math.random() * 800;
const theta = Math.random() * Math.PI * 2;
const phi = Math.acos(2 * Math.random() - 1);
positions[i * 3] = r * Math.sin(phi) * Math.cos(theta);
positions[i * 3 + 1] = r * Math.sin(phi) * Math.sin(theta);
positions[i * 3 + 2] = r * Math.cos(phi);
const temp = Math.random();
if (temp < 0.3) {
colors[i * 3] = 0.8; colors[i * 3 + 1] = 0.85; colors[i * 3 + 2] = 1.0;
} else if (temp < 0.6) {
colors[i * 3] = 1.0; colors[i * 3 + 1] = 0.95; colors[i * 3 + 2] = 0.8;
} else {
colors[i * 3] = 1.0; colors[i * 3 + 1] = 1.0; colors[i * 3 + 2] = 1.0;
}
sizes[i] = 0.3 + Math.random() * 1.2;
}
starsGeo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
starsGeo.setAttribute('color', new THREE.BufferAttribute(colors, 3));
starsGeo.setAttribute('size', new THREE.BufferAttribute(sizes, 1));
const starsMat = new THREE.ShaderMaterial({
uniforms: { uTime: { value: 0 } },
vertexShader: `
attribute float size;
varying vec3 vColor;
varying float vSize;
uniform float uTime;
void main() {
vColor = color;
vSize = size;
vec4 mvPos = modelViewMatrix * vec4(position, 1.0);
gl_PointSize = size * (200.0 / -mvPos.z);
gl_Position = projectionMatrix * mvPos;
}
`,
fragmentShader: `
varying vec3 vColor;
varying float vSize;
void main() {
float d = length(gl_PointCoord - 0.5);
if (d > 0.5) discard;
float alpha = smoothstep(0.5, 0.0, d);
gl_FragColor = vec4(vColor, alpha * 0.9);
}
`,
transparent: true,
vertexColors: true,
depthWrite: false,
blending: THREE.AdditiveBlending
});
return new THREE.Points(starsGeo, starsMat);
}
const stars = createStarfield();
scene.add(stars);
// ─── ATMOSPHERE SHADER ─────────────────────────────────────
const atmosphereVertexShader = `
varying vec3 vNormal;
varying vec3 vPosition;
void main() {
vNormal = normalize(normalMatrix * normal);
vPosition = (modelViewMatrix * vec4(position, 1.0)).xyz;
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;
const atmosphereFragmentShader = `
varying vec3 vNormal;
varying vec3 vPosition;
uniform vec3 uSunDirection;
void main() {
vec3 viewDir = normalize(-vPosition);
float fresnel = 1.0 - dot(viewDir, vNormal);
fresnel = pow(fresnel, 3.0);
float sunDot = dot(vNormal, uSunDirection);
float dayFactor = smoothstep(-0.2, 0.5, sunDot);
vec3 dayColor = vec3(0.3, 0.6, 1.0);
vec3 sunsetColor = vec3(0.8, 0.3, 0.1);
vec3 nightColor = vec3(0.05, 0.1, 0.3);
float sunsetFactor = smoothstep(0.0, 0.3, sunDot) * (1.0 - smoothstep(0.3, 0.6, sunDot));
vec3 atmosphereColor = mix(nightColor, dayColor, dayFactor);
atmosphereColor = mix(atmosphereColor, sunsetColor, sunsetFactor * 0.5);
float alpha = fresnel * (0.3 + dayFactor * 0.5);
gl_FragColor = vec4(atmosphereColor, alpha);
}
`;
// ─── EARTH GROUP ───────────────────────────────────────────
const earthGroup = new THREE.Group();
scene.add(earthGroup);
// Tilt Earth's axis
earthGroup.rotation.z = THREE.MathUtils.degToRad(23.44);
// ─── BUILD EARTH ───────────────────────────────────────────
let earthMesh, cloudMesh, atmosphereMesh, nightMesh;
let earthMaterial;
const state = {
clouds: true,
atmosphere: true,
night: false,
bump: true
};
async function init() {
// Load textures
const [
dayTex,
bumpTex,
specTex,
cloudTex,
nightTex
] = await Promise.all([
loadTexture(textureBaseURL + 'earth_atmos_2048.jpg'),
loadTexture(textureBaseURL + 'earth_normal_512.jpg'),
loadTexture(textureBaseURL + 'earth_specular_2048.jpg'),
loadTexture(textureBaseURL + 'earth_clouds_1024.png'),
loadTexture(textureBaseURL + 'earth_lights_2048.png')
]);
// ── Earth Sphere (PBR) ──
const earthGeo = new THREE.SphereGeometry(1, 128, 128);
earthMaterial = new THREE.MeshPhysicalMaterial({
map: dayTex,
bumpMap: bumpTex,
bumpScale: 0.04,
specularMap: specTex,
specularColor: new THREE.Color(0x333333),
roughnessMap: specTex,
roughness: 0.7,
metalness: 0.0,
clearcoat: 0.1,
clearcoatRoughness: 0.4,
envMapIntensity: 0.5
});
earthMesh = new THREE.Mesh(earthGeo, earthMaterial);
earthGroup.add(earthMesh);
// ── Night Lights Layer ──
const nightGeo = new THREE.SphereGeometry(1.001, 128, 128);
const nightMaterial = new THREE.MeshStandardMaterial({
map: nightTex,
emissiveMap: nightTex,
emissive: new THREE.Color(0xffcc66),
emissiveIntensity: 0,
transparent: true,
opacity: 0,
depthWrite: false
});
nightMesh = new THREE.Mesh(nightGeo, nightMaterial);
nightMesh.visible = false;
earthGroup.add(nightMesh);
// ── Cloud Layer ──
const cloudGeo = new THREE.SphereGeometry(1.01, 128, 128);
const cloudMaterial = new THREE.MeshStandardMaterial({
map: cloudTex,
transparent: true,
opacity: 0.45,
depthWrite: false,
blending: THREE.NormalBlending
});
cloudMesh = new THREE.Mesh(cloudGeo, cloudMaterial);
earthGroup.add(cloudMesh);
// ── Atmosphere Glow ──
const atmoGeo = new THREE.SphereGeometry(1.12, 64, 64);
const atmoMaterial = new THREE.ShaderMaterial({
uniforms: {
uSunDirection: { value: new THREE.Vector3(5, 3, 5).normalize() }
},
vertexShader: atmosphereVertexShader,
fragmentShader: atmosphereFragmentShader,
transparent: true,
side: THREE.BackSide,
depthWrite: false,
blending: THREE.AdditiveBlending
});
atmosphereMesh = new THREE.Mesh(atmoGeo, atmoMaterial);
earthGroup.add(atmosphereMesh);
// ── Sun Light (PBR) ──
const sunLight = new THREE.DirectionalLight(0xffffff, 3.0);
sunLight.position.set(5, 3, 5);
scene.add(sunLight);
const ambientLight = new THREE.AmbientLight(0x222244, 0.3);
scene.add(ambientLight);
// ── Environment Map (procedural) ──
const pmremGenerator = new THREE.PMREMGenerator(renderer);
const envScene = new THREE.Scene();
envScene.background = new THREE.Color(0x000011);
const envSun = new THREE.DirectionalLight(0xffffff, 5);
envSun.position.set(5, 3, 5);
envScene.add(envSun);
const envRT = pmremGenerator.fromScene(envScene);
earthMaterial.envMap = envRT.texture;
pmremGenerator.dispose();
// ── Hide Loading ──
const loadingEl = document.getElementById('loading');
loadingEl.style.opacity = '0';
setTimeout(() => loadingEl.style.display = 'none', 800);
return { sunLight, atmoMaterial };
}
// ─── UI CONTROLS ───────────────────────────────────────────
let sunLight, atmoMaterial;
document.getElementById('btnRotate').addEventListener('click', function() {
controls.autoRotate = !controls.autoRotate;
this.classList.toggle('active', controls.autoRotate);
});
document.getElementById('btnClouds').addEventListener('click', function() {
state.clouds = !state.clouds;
cloudMesh.visible = state.clouds;
this.classList.toggle('active', state.clouds);
});
document.getElementById('btnAtmo').addEventListener('click', function() {
state.atmosphere = !state.atmosphere;
atmosphereMesh.visible = state.atmosphere;
this.classList.toggle('active', state.atmosphere);
});
document.getElementById('btnNight').addEventListener('click', function() {
state.night = !state.night;
nightMesh.visible = state.night;
this.classList.toggle('active', state.night);
});
document.getElementById('btnBump').addEventListener('click', function() {
state.bump = !state.bump;
earthMaterial.bumpScale = state.bump ? 0.04 : 0.0;
this.classList.toggle('active', state.bump);
});
// Set initial active states — Night Lights starts OFF
document.getElementById('btnClouds').classList.add('active');
document.getElementById('btnAtmo').classList.add('active');
document.getElementById('btnBump').classList.add('active');
// ─── ANIMATION LOOP ────────────────────────────────────────
let sunDir = new THREE.Vector3(5, 3, 5).normalize();
function animate(time) {
requestAnimationFrame(animate);
const t = time * 0.001;
// Slow cloud rotation
if (cloudMesh && cloudMesh.visible) {
cloudMesh.rotation.y += 0.0001;
}
// Stars subtle twinkle via scale
stars.rotation.y += 0.00002;
// Update sun direction for atmosphere shader
if (atmoMaterial) {
// Slowly orbit the sun
const sunAngle = t * 0.05;
sunDir.set(
Math.cos(sunAngle) * 5,
3,
Math.sin(sunAngle) * 5
).normalize();
atmoMaterial.uniforms.uSunDirection.value.copy(sunDir);
if (sunLight) {
sunLight.position.copy(sunDir.clone().multiplyScalar(10));
}
// Night lights intensity based on viewing angle vs sun
if (nightMesh && nightMesh.visible) {
const camDir = camera.position.clone().normalize();
const sunToCam = 1.0 - Math.max(0, dot(camDir, sunDir));
nightMesh.material.emissiveIntensity = sunToCam * 2.0;
nightMesh.material.opacity = sunToCam * 0.9;
}
}
controls.update();
renderer.render(scene, camera);
}
function dot(a, b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}
// ─── INIT ──────────────────────────────────────────────────
init().then(({ sunLight: sl, atmoMaterial: am }) => {
sunLight = sl;
atmoMaterial = am;
animate(0);
});
// ─── RESIZE ────────────────────────────────────────────────
window.addEventListener('resize', () => {
camera.aspect = window.innerWidth / window.innerHeight;
camera.updateProjectionMatrix();
renderer.setSize(window.innerWidth, window.innerHeight);
});
</script>
</body>
</html>
I am not sure if you'll read this, but I have used your AWQ-4bit models for almost 8 months now. I run on L40S-90, L40S-180 and L4-360 via ovhcloud. You have made it possible to run decent models on 96GB vram or less. I have exclusive access to L40S and below GPU instances. Let me know if there is anything I can help out with. I build sovereign AI infrastructure that anyone can run on consumer hardware and can do 95% of foundational model tasks without issue. syndicateai.co, perceptor.us, passportalliance.org, aetherpro.us and redwatch.us.
I'm really interested in the details of that discovery that makes this update so much better! Could you tell us the technical details and the recipe?
As a user of these models, I can tell you that the difference is night and day. faster inference, fast model loading to GPU, preserves model capability and many other useful improvements that are better explained by using the models.
Sounds good!
Could you maybe calculate KLD for us?
I'm very curious to see how close we got to BF16!
This fork of VLLM allows you to run KLD:
https://github.com/phaelon74/vllm/tree/feature/score-mode-ppl-kld
Usage is explained here:
https://github.com/phaelon74/vllm/blob/feature/score-mode-ppl-kld/docs/features/score_mode.md
There are some KLD measurements here, including comparisons with other quantized models
https://www.reddit.com/r/LocalLLaMA/comments/1ssyukx/qwen3627b_klds_ints_and_nvfps/
EDIT: note, this is probably on old version