Z-GL 1.1.1 — The Premier Shader Desktop Environment

What's new in v1.1.1

Z-GL is now a native Windows desktop application with a full shader development workflow:

• Frameless window with custom title bar (Windows 11 design)
• Native Mica/Acrylic blur effects via window-vibrancy
• System tray with Open / Pause Render / Quit
• Native file dialogs and drag-and-drop for .glsl, .frag, .fs, .json
• File associations — open shaders directly from Windows Explorer
• CLI launch: z-gl.exe shader.glsl
• Most-recently-used (MRU) file list (last 10 paths)
• .zgl project format — bundles shader, metadata, channels and presets in a ZIP
• Auto-save every 30 seconds with crash recovery
• Hot-reload on external file changes
• Fixed-ratio rendering presets (720p, 1080p, 1440p, 4K)
• Headless screenshot export via OffscreenCanvas
• WebCodecs video export (MP4, WebM, PNG sequence)
• Timeline keyframe editor with Bézier curve view and dope sheet
• Multi-pass WebGPU pipelines (Buffers A/B/C/D) with rgba16float HDR targets
• WASM-based glslang pre-validation before GPU execution
• WGSL real-time preview panel alongside GLSL source
• Monaco GLSL ES 3.0 language service — syntax highlighting, hover docs, autocomplete, live error markers
• WebGPU timestamp-query GPU timing in the perf panel
• Single full-screen triangle draw call (replaces Three.js PlaneGeometry)
• SharedArrayBuffer + Atomics uniform writes — zero GC pressure

Z-GL 1.1.0 — The Premier Shader Desktop Environment

Changelog

All notable changes to the Z-GL shader desktop editor project for version 1.1.0 are documented below. This release primarily establishes the native desktop infrastructure for Windows 10/11 and advances the shader development workflow.

---

[1.1.0] - 2026-05-16

Added

• Native OS Window Integration: Switched to a frameless architecture leveraging native window decorations. Added a custom title bar with explicit drag regions, minimize, maximize, and close controls tailored for Windows 11 design guidelines.
• Mica & Acrylic Visuals: Integrated the window-vibrancy Tauri plugin to inject native Windows 11 Mica and Acrylic blur effects into the application layout shell.
• System Tray Management: Added a dedicated system tray icon featuring a native context menu allowing users to quickly Open the application instance, Pause Render execution to save processing cycles, or trigger a clean Quit.
• Dynamic Title Tracking: Added a title management routine updating the native OS window bar dynamically via window.setTitle(shaderName) during file imports or internal asset operations.
• Native File System Dialogs: Replaced standard web file picking hooks with secure, native OS file picking procedures powered by the Tauri dialog plugin API (openFileDialog, saveFileDialog).
• Drag-and-Drop Infrastructure: Implemented native file-drop interceptors enabling direct instantiation and parsing of .glsl, .frag, .fs, and .json file types dropped over the active viewport area.
• Windows Explorer Association: Added full file association capabilities via the NSIS compilation layout, allowing .glsl, .frag, and .fs files to launch natively within the Z-GL environment directly from disk.
• CLI Boot Operations: Added deep CLI argument routing support, allowing execution sequences like z-gl.exe shader.glsl to directly parse and ingest localized source fragments at startup.
• Local Application Hub Tracking: Introduced an automated Most-Recently-Used (MRU) tracking database in the File utility tree, maintaining the 10 most recent filesystem paths across individual application sessions.
• Project Structure Packaging (.zgl): Developed a localized project archiving protocol utilizing the current ZIP bundle mechanism. A .zgl archive bundles the core shader.glsl, a standard metadata file (meta.json), references to explicit input streaming channels (channels/), and localized multi-variable presets (presets/).
• Background Auto-Save Engine: Added a resilient auto-save pipeline writing persistent cache structures to a temporary data node every 30 seconds, coupled with automated recovery procedures triggered on unhandled app crashes.
• Hot-Reload Disk Watcher: Exposed an automated file monitoring option leveraging Tauri's system event detection loop to dynamically hot-reload asset sources on disk when edited inside an external IDE.
• Shader Channel Embedding: Configured an asset copying pipeline within the bundle logic to import and inline local channel streams (textures, audio targets) directly into the portable .zgl wrapper format.
• High-Resolution Frame Pacing: Enhanced the master RAF sequencer (raf-loop.js) with native support for requestVideoFrameCallback timestamps to maintain exact synchronization with high-refresh display hardware.
• WebGPU Metric Analysis: Added dedicated GPU timing reporting routines within the performance UI layer, driven by native WebGPU timestamp-query pipelines to calculate execution durations independently of JS main-thread runtime overhead.
• Fixed-Ratio Screen Profiling: Added predefined rendering resolution options (720p, 1080p, 1440p, 4K) running independently of the active viewport scaling metrics.
• Headless Screenshot Rendering: Added an alternative rendering pipeline utilizing OffscreenCanvas hooks for generating unthrottled screenshots and batch image exports without visual viewport stutter.
• Advanced Environment Diagnostics: Extended the performance dashboard to handle WebGL hardware extension evaluations, tracking specific runtime boundaries like maximum texture dimensions, floating-point texture alignment parameters, and MSAA sample counts.
• Monaco GLSL Language Service: Added a dedicated language registration package (monaco.languages.register) supporting GLSL ES 3.0 within the editor core.
• TextMate Highlighting Specification: Implemented a comprehensive TextMate grammar definition specifying unique highlighting behaviors for key operations, preprocessor controls, specific type variables, and internal constants.
• Semantic Token Profiling: Isolated core ShaderToy Uniform tokens (iTime, iResolution, iMouse, iChannel0-3) into distinct coloring criteria to differentiate system properties from arbitrary user definitions.
• Interactive API Documentation Tooltips: Integrated an inline hover service (monaco.languages.registerHoverProvider) mapping full signature details and parameter instructions to standard GLSL primitives and built-in uniforms.
• Intelligent Auto-Completion Registry: Bound automated snippet injection utilities providing template structures for common rendering techniques, Signed Distance Field (SDF) functions, and structural main blocks.
• Live Gutter Error Parsing: Connected an active syntax compiler that intercepts WebGL translation faults and binds red line/column error decorations to the text editor channel via monaco.editor.setModelMarkers.
• WGSL Compatibility Warners: Implemented diagnostic analyzer tracking for cross-compilation hazards (implicit data casting discrepancies, unstable ternary usage inside multi-layered operations, or array indexing anomalies) using yellow warning indicators.
• Structural Code Utilities: Activated multi-cursor edit paths, internal definition tracing routines, folding layouts for active preprocessor structures, custom color-coded bracket rules, and an AST-based command palette hookup.
• WGSL Transpiler Optimization: Upgraded the internal GLSL-to-WGSL transpilation module to safely map and unroll complex macro commands, structure loops, samplerCube binds, precision scopes, and explicit channel sampling formats (textureLod mappings).
• WGSL Real-Time Preview Panel: Introduced a split-pane structural view layout to actively inspect transpiled WGSL code side-by-side with the current GLSL source.
• WASM-Driven Input Verification: Embedded a local server-less version of the glslang compiler engine running in WebAssembly to analyze structural health prior to hardware execution passes.
• Dedicated WebGPU Pipeline Upgrade: Configured the WebGPU rendering framework to support structural multi-pass execution pipelines (Buffers A/B/C/D) via atomic GPUTexture ping-pong feedback loops, explicit pass-by-pass timestamp tracing, and HDR canvas target alignments (rgba16float).
• Timeline Keyframe Layout System: Designed a professional layout editor featuring an analytical curve view and an active dope-sheet timeline to bind, manipulate, and drag parameter values across linear, constant, or customized Bézier interpolation models.
• WebCodecs Rendering Exporters: Integrated hardware-accelerated video rendering routines into the application shell using WebCodecs options to process frame-accurate MP4, WebM, or PNG sequence exports.

Changed

• Macro Memory Execution Barriers: Unified all active frame routines into a singular system loop managed by gl/renderer.js to strictly maintain structural downward asset layers.
• Zero GC Uniform Write Pipeline: Refactored the core configuration structure to funnel input parameters using modern SharedArrayBuffer structures and Atomics memory operations, completely removing garbage collection performance hitches.
• Optimized Vertex Buffering Layout: Replaced standard Three.js PlaneGeometry arrays with a single full-screen triangle optimization routine to decrease processing requirements down to a single draw call without indexing overhead.

Z-GL 1.2.0 — The Premier Shader Desktop Environment

Changelog

All notable changes to Z-GL are documented here.
Format follows Keep a Changelog.

[1.2.0] — 20 mai 2026

Added — Mode headless CLI (Tauri)

• src/native/headless-cli.js — moteur headless complet (~430 lignes).
  • z-gl render --shader main.glsl --duration 10 --fps 60 --out output.mp4 — rendu offscreen Three.js sans fenêtre UI, encodage MP4/H.264 via WebCodecs (VideoEncoder).
  • z-gl render --timeline project.json --out frames/ — export séquence PNG depuis un projet Z-GL JSON avec timeline embarquée.
  • z-gl render --shader plasma.frag --out seq/ — export PNG séquence (détection automatique par / terminal ou absence d'extension).
  • Parser d'arguments minimaliste (--key value, flags booléens, positionnels).
  • Tous les defaults : --duration 10, --fps 60, --width 1920, --height 1080, --bitrate 8 (Mbit/s), --start-time 0.
  • Encodage H.264 (avc1.42E01E) ou séquence PNG, en fonction du suffixe --out.
  • Import de timeline via importTimelineJSON si project.timeline ou project.keyframes présent.
  • Flip vertical automatique des pixels WebGL (readPixels origin bas-gauche → PNG origin haut-gauche).
  • Logger de progression en barres █░ — notifie Tauri via headless_log IPC.
  • headless_exit IPC appelé en fin de run (code 0) ou sur erreur (code 1).
  • printHeadlessHelp() affichée pour --help, -h ou commande inconnue.
• src/native/headless-cli.test.js — 33 tests Vitest.
• src/app/init.js (modifié) — import runHeadlessCLI + early-exit si --headless render détecté dans les argv Tauri, sans monter l'UI.

Exemples d'utilisation

# MP4 10 s à 60 fps, 1920×1080
z-gl render --shader main.glsl --duration 10 --fps 60 --out output.mp4

# Séquence PNG 4K 30 fps
z-gl render --shader plasma.frag --width 3840 --height 2160 --fps 30 --out frames/

# Export depuis une timeline de projet
z-gl render --timeline project.json --out export.mp4

# Utilisable dans un Makefile
render: shaders/main.glsl
	z-gl render --shader $< --duration 5 --fps 60 --out dist/preview.mp4

Files

src/native/headless-cli.js (~430 lignes), src/native/headless-cli.test.js (~280 lignes).

---

[Unreleased] — 20 mai 2026

Added — Textures compressées natives (BC7 / ASTC / ETC2)

• src/render/texture-compressor.js — moteur de compression/cache (~630 lignes).
  • initTextureCompressor(gl) — détecte bestCompressedFormat via gl-caps.js, ouvre IndexedDB z-gl-tex-cache.
  • compressAndCacheTexture(blob, name) — charge l'image dans un OffscreenCanvas, calcule le SHA-256 du bitmap, consulte le cache IDB, compresse si absent (blocs 4×4 CPU), stocke le résultat.
  • loadCachedTexture(key) — lecture IDB directe depuis une clé connue.
  • getActiveFormat() — retourne 'bc7'|'astc'|'etc2'|'none' selon le GPU détecté.
  • purgeTextureCache() — vide le store IDB entier.
  • getTextureCacheStats() — { entries, totalBytes, format }.
  • Invalidation automatique si vendor::renderer::format change (fingerprint GPU).
  • Dégradation silencieuse si aucun format compressé : { compressed: false, url } → Three.js charge l'image normalement.
• src/render/texture-compressor.test.js — tests Vitest (~377 lignes) : init, compression BC7/ASTC/ETC2, hit/miss cache, stats, purge, passthrough sans GPU.
• src/channels/channels-media.js (modifié) — import compressAndCacheTexture + getActiveFormat ; _chLoadCompressedTexture() : upload gl.compressedTexImage2D avec le bon enum WebGL par format, wrappé en THREE.Texture ; fallback Three.js si result.compressed === false.

Formats GPU supportés

Format	Extension WebGL	Plateformes
BC7	EXT_texture_compression_bptc	Windows / Linux — AMD, NVIDIA, Intel
ASTC	WEBGL_compressed_texture_astc	Apple Silicon, Mali, Adreno (mobile)
ETC2	WEBGL_compressed_texture_etc	Android, Chrome OS

Files

src/render/texture-compressor.js (~630 lignes), src/render/texture-compressor.test.js (~377 lignes).

---

[Unreleased] — 20 mai 2026

Added

• Phase 13.5 — Image locale → Shader procédural
  • Drag & drop d'une image PNG/JPEG/WEBP/GIF → analyse locale complète (palette, luminance, fréquences spatiales) → shader GLSL procédural paramétrique généré par le LLM local.
  • Zéro donnée envoyée : tout tourne en canvas 2D + LLM Worker existant, aucune image ne quitte la machine.
  • Palette extraite par Median-Cut (6 couleurs dominantes) — algorithme utilisé par les éditeurs photo professionnels.
  • Analyse de luminance : mean, RMS contrast, gradient moyen, répartition dark/mid/bright, flags high-contrast/dark/bright.
  • Analyse de fréquences spatiales via DCT 8×8 blocs → 4 bandes → détection grain, smoothness, motifs répétitifs.
  • Panneau UI avec prévisualisation, palette inline, métriques, génération streamée, Apply/Copy/Cancel.
  • Raccourci Ctrl+Shift+I · bouton « Img→Shader » dans la barre d'outils · entrée Command Palette.
  • 38 tests Vitest (38/38 ✓).

Added

• Phase 13.3 — Commandes en langage naturel (panneau local)
  • Panneau AI Copilot refactorisé avec 4 onglets : Generate, Explain, Optimize, Refactor.
  • Mode Generate : prompt libre → patch GLSL/WGSL généré, prévisualisé en diff Monaco inline (éditeur diff côte-à-côte dans le panneau) avant application. Boutons ✓ Apply / ✕ Discard / Copy.
  • Mode Explain : utilise la sélection Monaco courante (ou tout le fichier si rien de sélectionné) → prose technique avec référence explicite aux uniforms Z-GL actifs (iTime, iResolution, iMouse, etc.). Aucun code en sortie.
  • Mode Optimize : analyse glsl-complexity.js existant (score ALU, branches, texture fetches, loops) → badge de complexité en temps réel dans le panneau → prompt structuré avec score intégré → suggestion de réécriture complète du shader prévisualisée en diff Monaco.
  • Mode Refactor : instruction en langage naturel (ex : "extrais cette boucle en fonction nommée fbmNoise") → shader refactorisé complet prévisualisé en diff Monaco. Interdit de renommer les uniforms Z-GL injectés.
  • Diff Monaco : monaco.editor.createDiffEditor inline-mode avec thème vs-dark, lecture seule, sans minimap. Fallback en diff texte coloré (+/-) si Monaco non disponible.
  • src/ai/ai-copilot-phase13-3.test.js — 40 tests Vitest couvrant les 4 modes : construction de prompts Explain/Optimize/Refactor, intégration scoreGLSL, extraction de blocs de code fencés, dialectes WGSL/HLSL.

Changed

• src/ai/ai-copilot-ui.js — refactorisé de ~555 à ~851 lignes. Largeur panneau élargie à 380px pour le diff. Import ajouté : scoreGLSL depuis ../shader/glsl-complexity.js. Fonctions ajoutées : _switchMode, _buildModePrompt, _showDiff, _showTextDiff, _hideDiff, _collectSelection, _handleApplyDiff, _handleDiscardDiff, _applyToEditor. Logique _handleGenerate unifiée pour tous les modes.

[Unreleased] — Tests · 20 mai 2026

Added

• src/shader/parser-extended.test.js — 90 nouveaux tests unitaires pour le parser GLSL : parseShader (defines, const globals, littéraux inline, directives preprocesseur), parseSymbols (fonctions, variables, structs, surcharges, tableaux, fallback regex), typeCheck (arité builtins, fonctions utilisateur, entiers passés à float fns), inferRange, categorize, buildLabel.

Fixed

• src/render/multipass.js — mpSetPassResScale : clampage de scale=0 retournait 1 au lieu de 0.125 (Number(0) || 1 → isNaN guard).
• src/shader/hlsl-transpiler.js — hlslToGlslStructural : le semantic : SV_Target n'était pas supprimé des signatures de retour avant {.
• src/shader/glsl-to-wgsl.test.js — Tests iDate/iSampleRate/iChannelTime/iChannelResolution mis à jour : ces uniforms sont désormais dans le struct _SLUniforms (plus de const). Test iFrame : regex flexible pour l'alignement.
• src/plugins/phase11.test.js — await import() à l'intérieur de blocs describe() remplacé par des import statiques (incompatible Rollup/Vitest).
• src/ai/local-model.test.js — require() CommonJS remplacé par await import() ESM pour accéder au mock safeLocalSet.

Stats

• 779 tests passent (18 fichiers) — 0 échec.

Added

• src/render/hdr.js — module HDR complet : détection canvas HDR Tauri (Display-P3), activation/désactivation, 7 tone mappers GLSL (None, Reinhard, ACES Filmic, Filmic Hable, AGX, Reinhard étendu, Lottes), export 16-bit PNG via Float32Array → ImageData (fallback natif navigateur), export OpenEXR pur JS avec fallback tinyexr-wasm.
• src/render/hdr-ui.js — panneau UI draggable HDR : toggle canvas HDR (Tauri), sélecteur de tone mapper, boutons export 16-bit PNG / OpenEXR avec sélection des passes RGBA.
• src/render/perf.js (modifié) — 5 tone mappers supplémentaires dans POST_FRAG : hable(), agx(), reinhardExt(), lottes(). Dispatch étendu de 2 à 7 modes dans applyToneMapper.
• src/ui.html (modifié) — 5 nouvelles <option> dans #toneMapSel (Filmic Hable, AGX, Reinhard étendu, Lottes) + bouton #hdrToggleBtn dans la barre d'outils.
• src/ui/editor.js (modifié) — lazy-load hdr-ui.js, exports openHDRPanel, closeHDRPanel, toggleHDRPanel, raccourci Ctrl+Shift+E, entrée Command Palette.
• src/ui/events.js (modifié) — import toggleHDRPanel + binding #hdrToggleBtn.

[1.1.19] — 2026-05-20

Added — Volume Rendering (iVolume, VDB, DICOM, Transfer Function)

• src/render/volume-renderer.js — Moteur volume : uploadVolume(data, w, h, d) charge les données voxel en TEXTURE_3D WebGL2 (unit 6) ou en atlas 2D automatique si WebGL2 indisponible (tuil...

Z-GL 1.0.0 — The Premier Shader Desktop Environment

Z-GL — The Premier Shader Desktop Environment

Z-GL is a high-performance, professional-grade shader development environment designed for Windows. It provides a native workspace to write, test, and perform real-time graphics with industry-leading efficiency.

---

✨ Features for Artists & Creators

🖥️ High-End Rendering

• Hybrid Engine: Seamlessly switch between WebGL and WebGPU to leverage the full power of your hardware.
• Cinematic Post-Processing: Includes high-quality bloom, ACES tone mapping, vignette, and sRGB correction.
• Multi-Pass Support: Create complex effects using Buffer A/B/C/D architecture, fully compatible with the ShaderToy ecosystem.
• Ultra-Resolution Support: Render at fixed resolutions from 720p to 4K, or set custom sizes independent of your window scale.

✍️ Elite Editor Experience

• Smart Code IDE: Features full GLSL syntax highlighting, auto-completion, and hover documentation for all built-in functions.
• Live Diagnostics: Real-time error markers and warnings catch bugs instantly as you type.
• Automatic Parameters: Variables defined via #define or const are automatically extracted into interactive UI sliders.
• External IDE Support: Use "Watch Mode" to edit code in VS Code or Neovim while Z-GL updates instantly in the background.

🎹 Live Performance & Hardware

• MIDI Learn: Bind any shader parameter to your MIDI controller knobs or sliders with a single click.
• Audio Reactivity: Integrated FFT analysis for microphone or system audio to drive dynamic visuals.
• Native Windows Design: Features Windows 11 Mica and Acrylic effects with a dedicated system tray icon.

---

🛠 Shortcuts & Controls

Shortcut	Action
Ctrl + S	Save current project
Ctrl + E	Export current frame as PNG
Ctrl + F	Auto-format GLSL code
F11	Toggle Fullscreen Viewport
F1	Open built-in GLSL documentation

---

📦 Getting Started

1. Installation: Run Z-GL_Setup.exe to install as a native Windows application.
2. Projects: Save your work as .zgl files—a portable ZIP format that bundles your shader code and assets.
3. Import: Drag and drop any .glsl, .frag, or .json file directly into the window to begin.

---

📋 System Requirements

• OS: Windows 10 or Windows 11 (x64).
• GPU: NVIDIA GT 1030 / GTX 1080 or equivalent (DirectX 12 / WebGPU support recommended).
• Memory: Optimized for systems with 16 GB DDR3 or higher.

Author: Patrick JAILLET
Version: 2026.05 — 1.0.0 Release