AutoGineer
Generated banner for Glass Dark Mode Clock
Generated logo for Glass Dark Mode Clock

Glass Dark Mode Clock

Meng ToCommunityCreated by Meng To

  • Skill
  • Content generator
  • Design and creative
  • MIT
  • Medium risk
Download ZIP

From the author

Create a dark glass design system with frosted shells, soft beam grids, circular clock-like calibration dials, and precise sci-fi instrument framing.
— the description by Meng To

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a comprehensive design framework for building dark-mode interfaces that prioritize a precise, instrument-like aesthetic. It moves beyond generic glassmorphism by focusing on a cohesive system of frosted-black surfaces, subtle beam grids, and a central circular calibration dial. The guide emphasizes a monochrome palette, cinematic lighting, and controlled motion to create a meditative, high-end user experience suitable for technical or data-driven applications.

What it does

  • Defines a visual language for dark glass surfaces with frosted effects and thin, crisp highlights.
  • Provides structural patterns for integrating circular, clock-like calibration dials into web layouts.
  • Establishes a monochrome color palette using black, white, zinc, and smoky gray tones.
  • Offers guidance on implementing subtle, continuous motion for rings, beams, and interface elements.
  • Outlines layout strategies for balancing technical instrument framing with clean, sparse typography.
  • Sets rules for maintaining a premium, non-muddy glass aesthetic through controlled opacity and blur.

When to use it

  • When designing a high-end, dark-themed interface that requires a scientific or cinematic feel.
  • When you need to anchor a page layout around a central, functional-looking circular component.
  • When building dashboards or landing pages that benefit from a precise, instrument-panel aesthetic.
  • When you want to implement glassmorphism that feels engineered rather than decorative or pastel-heavy.

Advantages

  • Creates a distinct, professional visual identity that avoids common design tropes.
  • Provides clear, actionable constraints to ensure visual consistency across complex interfaces.
  • Promotes a meditative and stable user experience through slow, controlled motion and restrained lighting.
  • Ensures high readability by balancing dark glass layers with precise, high-contrast typography.

Usage examples

“Apply the glass dark mode clock system to a new dashboard landing page.”
The agent will structure the page with a fixed dark nav, a low-contrast grid background, and a central circular calibration dial, using frosted-black capsules for controls.
“How should I style the hero section for a sci-fi instrument interface?”
The agent will recommend a split layout featuring a central circular dial with degree labels and rotating rings, balanced by sparse, clean hero copy.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/mengto/glass-dark-mode-clock/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip glass-dark-mode-clock.zip -d .agents/skills

Documentation by Meng To

Glass Dark Mode Clock Skill

Use When

  • Create a dark glass design system with frosted shells, soft beam grids, circular clock-like calibration dials, and precise sci-fi instrument framing.

Workflow

Scope

  • Apply this as a full design-system direction across background, shells, navigation, hero layout, controls, circular focal components, and motion.

  • Use it when the interface should feel like a premium dark instrument panel with glassy surfaces and a clock, dial, or calibration-device centerpiece.

  • This is not generic glassmorphism and not just a standalone radial widget. The full interface should support the clock-like system aesthetic.

Visual target

  • Build the page on a black or near-black base with very subtle grid lines, vertical and horizontal beam guides, and faint structural crosshairs.

  • Use dark glass or frosted-black surfaces for nav bars, pills, and controls, with blur, thin white edge gradients, and restrained reflection.

  • Introduce a dominant circular focal element that feels like a clock, calibration dial, or resonance instrument with rings, ticks, degrees, or rotating text paths.

  • Keep the palette mostly monochrome: black, white, zinc, and smoky gray. Accent brightness should come from glass highlights and soft white glow rather than saturated color.

  • Let the result feel precise, scientific, and slightly cinematic, with the circular dial anchoring the page like a timekeeping or calibration device.

Implementation guidance

  • Use frosted shells with thin gradient borders, low-opacity fills, and soft backdrop blur for navigation, pills, and action controls.

  • Support the circular centerpiece with crosshair lines, calibration marks, mono labels, radial rings, and small interface cues so it feels engineered.

  • The clock or dial should be layered: outer ring, tick marks, rotating labels or text, central core, and optional hex or geometric inner frame.

  • Keep hero copy clean and sparse, placed beside the dial within a split layout or balanced two-column composition.

  • If motion is present, favor slow rotating rings, drifting beams, subtle wisps, and gentle reveal sequences. Motion should feel continuous and meditative rather than flashy.

  • Glass treatment should stay dark and premium. Avoid translucent white blobs; use controlled smoky fills with crisp highlights instead.

Recommended patterns

  • Fixed dark nav with backdrop blur and thin bottom border floating above a low-contrast grid field.

  • Eyebrow pills and buttons built as glass-dark capsules with 1px highlight wrappers and clean inner dark fill.

  • Circular hero dial with outer text path, degree labels, rotating tick groups, and a minimal center emblem.

  • Background beam lines and crosshairs that align with the circular module and typography to reinforce calibration logic.

  • Soft white wisps, fog, or radial highlight inside the dial zone to make the glass and clock surfaces feel alive.

Tuning knobs

  • Glass strength: tune blur, opacity, and highlight intensity so surfaces read premium without becoming muddy.

  • Dial complexity: add or reduce rings, ticks, labels, and technical markers depending on how instrument-like the system should feel.

  • Motion tempo: keep rotations and beam sweeps slow enough to feel stable and controlled.

  • Contrast: preserve strong readability between white text, gray support copy, and the dark glass layers.

  • Glow restraint: use soft white glow only near focal glass edges or inside the dial, not across the whole page.

Avoid

  • Generic pastel glassmorphism with bright translucent cards floating on colorful blobs.

  • Treating the clock motif as a decorative afterthought disconnected from the layout.

  • Overloading the dial with too many labels or motion until it becomes noisy.

  • Using strong accent colors that break the monochrome calibration aesthetic.

  • Flattening everything into plain black boxes with no glass depth, beam structure, or radial hierarchy.

Files

demo/index.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta name="neuform-sandboxed-demo" content="1">
  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; connect-src 'self'; frame-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'; object-src 'none'">
  <title>Sandboxed Neuform demo</title>
  <style>
    html, body, iframe { width: 100%; height: 100%; margin: 0; border: 0; }
    body { overflow: hidden; background: #0b0b0b; }
    iframe { display: block; background: white; }
    .error { box-sizing: border-box; min-height: 100%; padding: 32px; color: #fff; font: 16px/1.5 system-ui, sans-serif; }
  </style>
</head>
<body>
  <iframe id="neuform-demo" title="Sandboxed Neuform design demo" sandbox="allow-scripts" referrerpolicy="no-referrer"></iframe>
  <script>
    const encodedHtml = "<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="Content-Security-Policy" content="default-src 'none'; base-uri 'none'; connect-src 'none'; font-src data: https://fonts.gstatic.com; form-action 'none'; frame-src 'none'; img-src blob:; media-src blob:; navigate-to 'none'; object-src 'none'; script-src 'unsafe-inline' __NEUFORM_RUNTIME_SOURCES__; style-src 'unsafe-inline' https://api.fontshare.com https://fonts.googleapis.com; worker-src 'none'">
<script data-neuform-asset-bootstrap>
(() => {
  let received = false;
  const objectUrls = [];
  const replaceAll = (value, replacements) => {
    let next = String(value || "");
    for (const [file, objectUrl] of replacements) next = next.split(file).join(objectUrl);
    return next;
  };
  window.addEventListener("message", (event) => {
    if (received || event.source !== parent || event.data?.type !== "neuform-assets-v1") return;
    received = true;
    const replacements = [];
    for (const asset of event.data.assets || []) {
      if (!asset || typeof asset.file !== "string" || typeof asset.base64 !== "string") continue;
      const binary = atob(asset.base64);
      const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
      const objectUrl = URL.createObjectURL(new Blob([bytes], { type: asset.contentType || "application/octet-stream" }));
      objectUrls.push(objectUrl);
      replacements.push([asset.file, objectUrl]);
    }
    for (const element of document.querySelectorAll("*")) {
      for (const name of ["src", "poster", "srcset", "style"]) {
        const value = element.getAttribute(name);
        if (value) element.setAttribute(name, replaceAll(value, replacements));
      }
    }
    for (const style of document.querySelectorAll("style")) {
      style.textContent = replaceAll(style.textContent, replacements);
    }
  });
  window.addEventListener("pagehide", () => {
    for (const objectUrl of objectUrls) URL.revokeObjectURL(objectUrl);
  }, { once: true });
})();
</script>

<meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Alert Interface</title>
    <script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
    <script src="../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js"></script>
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@200;300;400;500;600&display=swap" rel="stylesheet">
</head>
<body class="bg-zinc-200 min-h-screen flex items-center justify-center p-4 antialiased text-black" style="font-family: 'Inter', -apple-system, sans-serif; overflow: hidden;">

    <!-- Device Frame -->
    <div class="relative w-full max-w-[390px] h-[844px] bg-[#e4e4e2] rounded-[3.5rem] shadow-2xl overflow-hidden border-[8px] border-zinc-800 flex flex-col scale-[0.85] sm:scale-100 origin-center transition-transform duration-500">
        
        <!-- Status Bar -->
        <div class="flex items-center justify-between px-7 pt-4 pb-2 text-xs font-medium z-20">
            <span class="tracking-wider">9:41</span>
            <!-- Dynamic Island Mock -->
            <div class="w-32 h-7 bg-black rounded-full absolute left-1/2 -translate-x-1/2 top-3"></div>
            <div class="flex gap-1.5 items-center">
                <iconify-icon icon="solar:cellular-network-linear" class="text-sm"></iconify-icon>
                <iconify-icon icon="solar:wifi-linear" class="text-sm"></iconify-icon>
                <iconify-icon icon="solar:battery-charge-linear" class="text-base"></iconify-icon>
            </div>
        </div>

        <!-- Header -->
        <div class="px-7 pt-2 pb-6 flex items-center justify-between z-20">
            <h1 class="text-3xl font-semibold tracking-tighter" style="letter-spacing: -0.05em;">Alerts</h1>
            <iconify-icon icon="solar:alt-arrow-down-linear" class="text-xl"></iconify-icon>
        </div>

        <!-- Main Display -->
        <div class="flex flex-col items-center justify-center z-20" id="main-time-container" style="opacity: 0; transform: translateY(10px);">
            <div class="flex items-baseline justify-center font-light tracking-tighter" style="letter-spacing: -0.06em; line-height: 0.9;">
                <span class="text-8xl text-black">07</span>
                <span class="text-8xl text-[#949494]">:15</span>
            </div>
            <div class="mt-4 text-xs font-medium text-[#7a7a7a] tracking-wide">
                The next alert rings in <span class="text-black font-semibold">2h 15m</span>
            </div>
        </div>

        <!-- WebGL Visualization (Barcode) -->
        <div class="mx-6 mt-8 h-40 bg-[#dbdbd8] rounded-2xl relative overflow-hidden shadow-inner z-10" id="barcode-container" style="opacity: 0;">
            <canvas id="webgl-barcode" class="absolute inset-0 w-full h-full"></canvas>
            <!-- Red Indicator Line -->
            <div class="absolute inset-y-0 left-1/2 w-[1px] bg-[#ff3a1a] z-20 shadow-[0_0_10px_rgba(255,58,26,0.6)]"></div>
        </div>

        <!-- Days Selector -->
        <div class="flex justify-between items-center px-8 mt-8 text-xs font-medium text-[#949494] z-20" id="days-container" style="opacity: 0;">
            <span>Sun</span>
            <span>Mon</span>
            <div class="relative flex items-center justify-center w-9 h-9">
                <div class="absolute inset-0 bg-[#ff3a1a] rounded-full -rotate-12 shadow-sm"></div>
                <span class="relative z-10 text-black font-semibold">Tue</span>
            </div>
            <span>Wed</span>
            <span>Thu</span>
            <span>Fri</span>
            <span>Sat</span>
        </div>

        <!-- Horizontal Scroll Cards -->
        <div class="mt-8 flex gap-3 overflow-x-auto px-6 pb-24 snap-x z-20" style="scrollbar-width: none; -ms-overflow-style: none;" id="cards-container">
            <!-- Card 1 -->
            <div class="min-w-[260px] bg-[#d9d9d6] rounded-[24px] p-5 snap-center flex justify-between items-center relative overflow-hidden transition-transform duration-300 active:scale-95">
                <div class="flex flex-col z-10">
                    <div class="flex items-baseline gap-1 tracking-tighter">
                        <span class="text-5xl font-light text-black">07</span>
                        <span class="text-5xl font-light text-[#8a8a8a]">:15</span>
                        <span class="text-xs font-semibold text-[#666] uppercase mb-4 ml-1">am</span>
                    </div>
                    <div class="mt-1 text-xs font-medium text-black">
                        Deep Focus <span class="text-[#777] ml-1">· Ambient</span>
                    </div>
                </div>
                <iconify-icon icon="solar:play-bold" class="text-2xl text-black z-10"></iconify-icon>
            </div>
            <!-- Card 2 -->
            <div class="min-w-[260px] bg-[#d9d9d6] rounded-[24px] p-5 snap-center flex justify-between items-center relative overflow-hidden transition-transform duration-300 active:scale-95">
                <div class="flex flex-col z-10">
                    <div class="flex items-baseline gap-1 tracking-tighter">
                        <span class="text-5xl font-light text-black">08</span>
                        <span class="text-5xl font-light text-[#8a8a8a]">:30</span>
                        <span class="text-xs font-semibold text-[#666] uppercase mb-4 ml-1">am</span>
                    </div>
                    <div class="mt-1 text-xs font-medium text-black">
                        Daily Standup <span class="text-[#777] ml-1">· Meeting</span>
                    </div>
                </div>
                <iconify-icon icon="solar:play-bold" class="text-2xl text-black z-10 opacity-30"></iconify-icon>
            </div>
        </div>

        <!-- Bottom Control Bar -->
        <div class="absolute bottom-6 left-5 right-5 h-[72px] bg-[#141414] rounded-full flex items-center justify-between px-5 z-30 shadow-2xl">
            <button class="w-10 h-10 flex items-center justify-center text-[#777] hover:text-white transition-colors">
                <iconify-icon icon="solar:calendar-linear" class="text-xl"></iconify-icon>
            </button>
            
            <!-- Scrolling Ruler Canvas -->
            <div class="flex-1 h-full mx-2 relative overflow-hidden flex flex-col justify-end pb-3">
                <canvas id="ruler-canvas" class="absolute inset-0 w-full h-full"></canvas>
                <!-- Central Indicator overlay -->
                <div class="absolute inset-0 flex flex-col items-center justify-between pt-2 pb-[10px] pointer-events-none">
                    <span class="text-white text-xs font-semibold drop-shadow-md">07:15</span>
                    <div class="w-[1.5px] h-4 bg-[#ff3a1a] rounded-full"></div>
                </div>
            </div>

            <button class="w-10 h-10 flex items-center justify-center text-[#777] hover:text-white transition-colors">
                <iconify-icon icon="solar:add-circle-linear" class="text-xl"></iconify-icon>
            </button>
        </div>
    </div>

    <script>
        // --- Intro Animations ---
        document.addEventListener("DOMContentLoaded", () => {
            const animateIn = (id, delay) => {
                const el = document.getElementById(id);
                if(!el) return;
                let start = null;
                const duration = 800;
                const easeOutQuart = t => 1 - (--t) * t * t * t;
                
                const step = (timestamp) => {
                    if (!start) start = timestamp;
                    const progress = Math.min((timestamp - start) / duration, 1);
                    const ease = easeOutQuart(progress);
                    
                    el.style.opacity = ease;
                    if(el.id === 'main-time-container') {
                        el.style.transform = `translateY(${(1 - ease) * 20}px)`;
                    }
                    if (progress < 1) {
                        window.requestAnimationFrame(step);
                    }
                };
                setTimeout(() => window.requestAnimationFrame(step), delay);
            };

            animateIn('main-time-container', 100);
            animateIn('barcode-container', 300);
            animateIn('days-container', 500);
            
            // Cards stagger
            const cards = document.getElementById('cards-container').children;
            Array.from(cards).forEach((card, i) => {
                card.style.opacity = '0';
                card.style.transform = 'translateX(20px)';
                setTimeout(() => {
                    let start = null;
                    const step = (timestamp) => {
                        if (!start) start = timestamp;
                        const p = Math.min((timestamp - start) / 600, 1);
                        const e = 1 - Math.pow(1 - p, 4);
                        card.style.opacity = e;
                        card.style.transform = `translateX(${(1 - e) * 20}px)`;
                        if (p < 1) window.requestAnimationFrame(step);
                    };
                    window.requestAnimationFrame(step);
                }, 600 + (i * 150));
            });
        });

        // --- WebGL Barcode Background ---
        const initWebGL = () => {
            const canvas = document.getElementById('webgl-barcode');
            const gl = canvas.getContext('webgl', { antialias: false });
            if (!gl) return;

            const resize = () => {
                const rect = canvas.parentElement.getBoundingClientRect();
                canvas.width = rect.width * window.devicePixelRatio;
                canvas.height = rect.height * window.devicePixelRatio;
                gl.viewport(0, 0, canvas.width, canvas.height);
            };
            window.addEventListener('resize', resize);
            resize();

            const vsSource = `
                attribute vec2 position;
                void main() { gl_Position = vec4(position, 0.0, 1.0); }
            `;
            const fsSource = `
                precision mediump float;
                uniform vec2 u_resolution;
                uniform float u_time;

                // Random function
                float random(float x) {
                    return fract(sin(x) * 43758.5453123);
                }

                void main() {
                    vec2 uv = gl_FragCoord.xy / u_resolution.xy;
                    
                    // Slower scroll speed
                    float scrollX = uv.x + u_time * 0.02; 
                    
                    // Density of bars
                    float density = 150.0; 
                    float index = floor(scrollX * density);
                    
                    // Generate random value per bar
                    float rnd = random(index);
                    
                    // Create lines: threshold random value. 
                    // Higher threshold = fewer lines
                    float line = step(0.35, rnd);
                    
                    // Vary opacity based on random value, keep it subtle
                    float alpha = line * rnd * 0.4;
                    
                    // Color is black/dark gray, relying on alpha for subtlety against bg
                    gl_FragColor = vec4(0.0, 0.0, 0.0, alpha);
                }
            `;

            const createShader = (type, source) => {
                const shader = gl.createShader(type);
                gl.shaderSource(shader, source);
                gl.compileShader(shader);
                return shader;
            };

            const program = gl.createProgram();
            gl.attachShader(program, createShader(gl.VERTEX_SHADER, vsSource));
            gl.attachShader(program, createShader(gl.FRAGMENT_SHADER, fsSource));
            gl.linkProgram(program);
            gl.useProgram(program);

            const vertices = new Float32Array([-1,-1, 1,-1, -1,1, 1,1]);
            const buffer = gl.createBuffer();
            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
            gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);

            const posLoc = gl.getAttribLocation(program, 'position');
            gl.enableVertexAttribArray(posLoc);
            gl.vertexAttribPointer(posLoc, 2, gl.FLOAT, false, 0, 0);

            const timeLoc = gl.getUniformLocation(program, 'u_time');
            const resLoc = gl.getUniformLocation(program, 'u_resolution');

            const render = (time) => {
                gl.uniform1f(timeLoc, time * 0.001);
                gl.uniform2f(resLoc, canvas.width, canvas.height);
                gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
                requestAnimationFrame(render);
            };
            requestAnimationFrame(render);
        };
        initWebGL();

        // --- 2D Canvas Scrolling Ruler ---
        const initRuler = () => {
            const canvas = document.getElementById('ruler-canvas');
            const ctx = canvas.getContext('2d', { alpha: false }); // optimize
            if(!ctx) return;

            let w, h;
            const resize = () => {
                const rect = canvas.parentElement.getBoundingClientRect();
                w = rect.width;
                h = rect.height;
                canvas.width = w * window.devicePixelRatio;
                canvas.height = h * window.devicePixelRatio;
                ctx.scale(window.devicePixelRatio, window.devicePixelRatio);
            };
            window.addEventListener('resize', resize);
            resize();

            const tickSpacing = 6;
            const scrollSpeed = 10; // pixels per second

            let lastTime = 0;
            let offset = 0;

            const renderRuler = (time) => {
                const deltaTime = (time - lastTime) / 1000;
                lastTime = time;
                
                offset -= scrollSpeed * deltaTime;
                if (offset <= -tickSpacing * 10) {
                    offset += tickSpacing * 10;
                }

                // Fill background
                ctx.fillStyle = '#141414';
                ctx.fillRect(0, 0, w, h);

                ctx.lineWidth = 1;
                
                const startX = offset % tickSpacing;
                let tickCount = 0;

                // Draw ticks
                for (let x = startX; x < w; x += tickSpacing) {
                    // Determine tick height based on interval (simulating 10 unit groups)
                    const isMajor = Math.abs((x - offset) % (tickSpacing * 10)) < 0.1;
                    const isMid = Math.abs((x - offset) % (tickSpacing * 5)) < 0.1 && !isMajor;
                    
                    let tickHeight = 6; // minor
                    if (isMajor) tickHeight = 14;
                    if (isMid) tickHeight = 10;

                    // Draw from bottom up
                    ctx.beginPath();
                    ctx.moveTo(x, h - 10);
                    ctx.lineTo(x, h - 10 - tickHeight);
                    
                    // Fade out edges
                    const distFromCenter = Math.abs(x - w/2);
                    const fadeStart = w * 0.2;
                    let alpha = 1;
                    if(distFromCenter > fadeStart) {
                        alpha = Math.max(0, 1 - (distFromCenter - fadeStart) / (w/2 - fadeStart));
                    }
                    
                    ctx.strokeStyle = `rgba(119, 119, 119, ${alpha * (isMajor ? 0.8 : 0.4)})`;
                    ctx.stroke();
                }

                requestAnimationFrame(renderRuler);
            };
            requestAnimationFrame((t) => { lastTime = t; renderRuler(t); });
        };
        initRuler();

    </script>
</body>
</html>
";
    const assetFiles = [];
    const runtimeFiles = ["../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js","../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"];
    const frame = document.getElementById("neuform-demo");
    const decodeBytes = (value) => Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
    const decode = (value) => new TextDecoder().decode(decodeBytes(value));
    const encodeBytes = (bytes) => {
      let binary = "";
      for (let index = 0; index < bytes.length; index += 32768) {
        binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
      }
      return btoa(binary);
    };
    const mediaTypes = {
      avif: "image/avif",
      gif: "image/gif",
      jpg: "image/jpeg",
      jpeg: "image/jpeg",
      mp4: "video/mp4",
      png: "image/png",
      webm: "video/webm",
      webp: "image/webp"
    };
    const loadAsset = async (file) => {
      const response = await fetch(file, { cache: "no-store", credentials: "omit", redirect: "error" });
      if (!response.ok) throw new Error("Could not load local demo asset: " + file);
      const extension = file.split(".").pop().toLowerCase();
      const contentType = mediaTypes[extension] || "application/octet-stream";
      const bytes = new Uint8Array(await response.arrayBuffer());
      return { base64: encodeBytes(bytes), contentType, file, kind: "asset" };
    };
    Promise.allSettled(assetFiles.map(loadAsset)).then((results) => {
      const runtimeSources = runtimeFiles.map((file) => new URL(file, location.href).href).join(" ");
      const source = decode(encodedHtml).replace("__NEUFORM_RUNTIME_SOURCES__", runtimeSources);
      const mediaAssets = [];
      for (const result of results) {
        if (result.status !== "fulfilled") continue;
        mediaAssets.push(result.value);
      }
      frame.addEventListener("load", () => {
        frame.contentWindow.postMessage({ type: "neuform-assets-v1", assets: mediaAssets }, "*");
      }, { once: true });
      frame.srcdoc = source;
    }).catch((error) => {
      document.body.innerHTML = '<div class="error">Unable to load this sandboxed demo.</div>';
      console.error(error);
    });
  </script>
</body>
</html>

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Meng To
Publisher
Meng To (Community)
Source
MengTo/Skills · agent-skills/web-design/glass-dark-mode-clock · commit 5ea1661
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Meng To.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download glass-dark-mode-clock.zip