Generated banner for Company Logos
Generated logo for Company Logos

Company Logos

Meng ToCommunityCreated by Meng To

  • Skill
  • Guidelines
  • Design and creative
  • MIT
  • Medium risk

From the author

Use Iconify Simple Icons logos (64x64) instead of text logos.
— the description by Meng To

AutoGineer summary

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

The Company Logos skill provides a standardized approach to incorporating brand marks into digital designs. By leveraging Iconify Simple Icons, it ensures a uniform visual treatment for logos in grids, partner lists, and customer proof sections, moving away from text-based representations.

What it does

  • Defines the use of Iconify Simple Icons as the primary source for brand marks.
  • Sets a standard 64x64 visual box for logo placement.
  • Provides rules for monochrome versus brand-colored logo rendering.
  • Establishes alignment practices for consistent grid and row layouts.
  • Mandates the inclusion of accessible labels for interactive elements.

When to use it

  • When creating logo rows or integration grids.
  • When displaying customer proof or partner lists.
  • When you need to avoid embedding custom SVG files or plain text names.
  • When maintaining visual consistency across tool badges.

Advantages

  • Promotes visual uniformity by avoiding mixed styles.
  • Ensures accessibility through required labeling.
  • Reduces reliance on external or unverified logo assets.
  • Creates intentional, aligned layouts for brand marks.

Usage examples

“How should I display a list of partner logos in my design?”
The agent will guide you to use Iconify Simple Icons, set them in 64x64 boxes, maintain a consistent monochrome style, and ensure they are aligned to a shared baseline.
“Can I mix different styles of logos in my customer proof section?”
The agent will advise against mixing filled, outline, or bitmap styles, recommending a consistent approach using the specified icon library.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/mengto/company-logos/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip company-logos.zip -d .agents/skills

Documentation by Meng To

Company Logos Skill

Use When

  • A design needs recognizable brand marks without embedding custom SVG files or rendering company names as plain text.

  • Logo rows, integrations grids, customer proof, partner lists, and tool badges need consistent icon treatment.

Workflow

  1. Use Iconify Simple Icons as the default source for brand logos.

  2. Render each logo in a 64x64 visual box, then scale the inner SVG to the composition density.

  3. Keep logos monochrome by default; use brand color only when the surrounding design needs recognition more than restraint.

  4. Align logos to a shared baseline or center grid so rows feel intentional.

  5. Add accessible labels when logos are interactive or communicate important proof.

Guardrails

  • Do not use typed company names as a replacement for logos unless no icon exists.

  • Do not mix filled, outline, emoji, bitmap, and wordmark styles in one row.

  • Do not hotlink random logo assets from search results.

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>Fluid Protocol | Flow Analytics</title>
    
    <script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
    <script src="../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js"></script>
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <link href="https://fonts.googleapis.com/css2?family=Instrument+Serif:ital@0;1&family=Inter:wght@300;400;500;600&display=swap" rel="stylesheet">
    
    <!-- GSAP -->
    <script src="../../../../assets/runtime/runtime-027051effa47-gsap-min.js"></script>
    <script src="../../../../assets/runtime/runtime-689ca8dda44c-scrolltrigger-min.js"></script>
    
    <!-- Three.js -->
    <script src="../../../../assets/runtime/runtime-2f01c69cbd22-three-min.js"></script>

    <script>
        tailwind.config = {
            theme: {
                extend: {
                    fontFamily: {
                        sans: ['Inter', 'sans-serif'],
                        serif: ['Instrument Serif', 'serif'],
                        mono: ['ui-monospace', 'SFMono-Regular', 'Menlo', 'Monaco', 'Consolas', "Liberation Mono", "Courier New", 'monospace'],
                    },
                    colors: {
                        glass: {
                            50: '#f8fafc',
                            100: '#f1f5f9',
                            200: '#e2e8f0',
                            300: '#cbd5e1',
                            400: '#94a3b8',
                            900: '#0f172a',
                        },
                        water: {
                            100: '#e0f2fe',
                            300: '#7dd3fc',
                            500: '#0ea5e9',
                        }
                    }
                }
            }
        }
    </script>
    <style>
        ::-webkit-scrollbar { display: none; }
        * { -ms-overflow-style: none; scrollbar-width: none; }
        
        .masked-word {
            display: inline-block;
            overflow: hidden;
            vertical-align: top;
        }
        .masked-word-inner {
            display: inline-block;
            transform: translateY(110%);
        }

        /* Subtle grid texture for the instrument panel */
        .bg-instrument-grid {
            background-image: 
                linear-gradient(to right, rgba(148, 163, 184, 0.05) 1px, transparent 1px),
                linear-gradient(to bottom, rgba(148, 163, 184, 0.05) 1px, transparent 1px);
            background-size: 40px 40px;
        }

        /* Custom range slider for calibration */
        input[type=range] {
            -webkit-appearance: none;
            width: 100%;
            background: transparent;
        }
        input[type=range]::-webkit-slider-thumb {
            -webkit-appearance: none;
            height: 16px;
            width: 8px;
            border-radius: 2px;
            background: #0f172a;
            cursor: pointer;
            margin-top: -6px;
            box-shadow: 0 0 10px rgba(255,255,255,1), inset 0 0 0 1px rgba(255,255,255,0.5);
            border: 1px solid rgba(15, 23, 42, 0.2);
        }
        input[type=range]::-webkit-slider-runnable-track {
            width: 100%;
            height: 4px;
            cursor: pointer;
            background: rgba(15, 23, 42, 0.1);
            border-radius: 2px;
            border: 1px solid rgba(255,255,255,0.5);
        }
        
        /* Rotating path text adjustment */
        .svg-text-path {
            font-size: 14px;
        }
    </style>
</head>
<body class="bg-glass-50 text-glass-900 font-sans antialiased overflow-x-hidden relative selection:bg-water-300/30 bg-instrument-grid min-h-screen">

    <!-- WebGL Fluid Canvas -->
    <canvas id="webgl-canvas" class="fixed inset-0 z-0 pointer-events-none opacity-80"></canvas>

    <!-- Calibration Crosshairs & Global Framing -->
    <div class="fixed inset-0 z-0 pointer-events-none flex justify-center px-4 md:px-8 mix-blend-multiply opacity-20">
        <div class="w-full max-w-7xl h-full border-x border-glass-400/20 flex justify-center relative">
            <div class="w-[1px] h-full bg-glass-400/20 absolute left-1/4 hidden md:block"></div>
            <div class="w-[1px] h-full bg-glass-400/20 absolute right-1/4 hidden md:block"></div>
            <div class="absolute w-full h-[1px] bg-glass-400/20 top-1/3"></div>
        </div>
    </div>

    <!-- Navigation -->
    <nav class="fixed top-8 left-1/2 -translate-x-1/2 z-50 w-full max-w-xl px-4">
        <!-- Thin Gradient Border Shell -->
        <div class="p-[1px] rounded-full bg-gradient-to-b from-white via-glass-200 to-glass-300 shadow-sm relative group">
            <div class="flex items-center justify-between bg-white/50 backdrop-blur-md px-6 py-3 rounded-full border border-white/60 shadow-[inset_0_2px_10px_rgba(255,255,255,1)]">
                <div class="flex items-center gap-2">
                    <iconify-icon icon="solar:waterdrops-linear" class="text-water-500 text-lg" stroke-width="1.5"></iconify-icon>
                    <span class="text-xs font-semibold text-glass-900 tracking-widest uppercase">Fluid_OS</span>
                </div>
                <div class="flex items-center gap-8 text-xs tracking-widest uppercase font-mono text-glass-400">
                    <a href="#" class="hover:text-glass-900 transition-colors">Telemetry</a>
                    <a href="#" class="hover:text-glass-900 transition-colors">Systems</a>
                </div>
                <div class="w-2 h-2 rounded-full bg-water-500 shadow-[0_0_8px_rgba(14,165,233,0.6)] animate-pulse"></div>
            </div>
        </div>
    </nav>

    <!-- Main Content -->
    <main class="relative z-10 w-full max-w-7xl mx-auto px-4 md:px-8 pt-48 pb-24 flex flex-col items-center">
        
        <!-- Hero Section -->
        <div class="w-full flex flex-col md:flex-row items-center justify-between gap-16 hero-reveal">
            
            <!-- Left Copy -->
            <div class="flex-1 max-w-xl relative">
                <div class="absolute -left-8 top-0 bottom-0 w-[1px] bg-gradient-to-b from-glass-300/0 via-glass-300 to-glass-300/0 hidden md:block"></div>
                
                <div class="inline-flex items-center gap-3 p-[1px] rounded-full bg-gradient-to-r from-white to-glass-200 mb-10 shadow-sm">
                    <div class="bg-white/60 backdrop-blur-sm px-4 py-1.5 rounded-full flex items-center gap-2 border border-white">
                        <iconify-icon icon="solar:radar-linear" class="text-glass-400 text-sm" stroke-width="1.5"></iconify-icon>
                        <span class="text-xs tracking-widest uppercase text-glass-500 font-mono">Calibration Complete</span>
                    </div>
                </div>
                
                <h1 class="font-serif text-5xl md:text-7xl tracking-tight text-glass-900 leading-[1.1] mb-8">
                    Orchestrate the <br> <span class="italic text-glass-400 font-normal">flow of capital.</span>
                </h1>
                
                <p class="text-base text-glass-500 font-normal leading-relaxed mb-10">
                    Channel liquidity through crystalline streams with sub-millisecond precision. A strict, calibrated instrument panel for unified asset navigation.
                </p>

                <div class="flex items-center gap-6">
                    <button class="p-[1px] rounded-full bg-gradient-to-b from-glass-400 to-glass-900 group shadow-md hover:shadow-lg transition-all">
                        <div class="bg-glass-900 px-8 py-3 rounded-full flex items-center gap-2 text-xs font-semibold text-white group-hover:bg-glass-800 transition-colors uppercase tracking-widest">
                            Initialize Sync
                            <iconify-icon icon="solar:arrow-right-linear" class="text-sm group-hover:translate-x-1 transition-transform" stroke-width="1.5"></iconify-icon>
                        </div>
                    </button>
                    <div class="flex flex-col gap-1 font-mono text-xs text-glass-400 uppercase tracking-widest">
                        <span>Latency</span>
                        <span class="text-glass-900 font-semibold">12ms <span class="text-water-500 animate-pulse">●</span></span>
                    </div>
                </div>
            </div>

            <!-- Right Clock/Dial Focal Element -->
            <div class="flex-1 flex justify-center items-center relative w-full max-w-md aspect-square">
                <!-- Glowing backdrop -->
                <div class="absolute inset-0 bg-white/20 blur-3xl rounded-full"></div>
                
                <div class="relative w-full h-full p-[1px] rounded-full bg-gradient-to-br from-white via-glass-200 to-glass-100 shadow-[0_20px_40px_rgba(0,0,0,0.03)]">
                    <div class="w-full h-full rounded-full bg-white/30 backdrop-blur-xl border border-white shadow-[inset_0_0_30px_rgba(255,255,255,0.8)] relative flex justify-center items-center overflow-hidden">
                        
                        <!-- Crosshairs -->
                        <div class="absolute w-full h-[1px] bg-glass-300/40"></div>
                        <div class="absolute h-full w-[1px] bg-glass-300/40"></div>
                        
                        <!-- Outer Rotating Text Ring -->
                        <div class="absolute inset-4 animate-[spin_40s_linear_infinite] opacity-60">
                            <svg viewBox="0 0 200 200" class="w-full h-full overflow-visible text-glass-500">
                                <path id="textPath" d="M 100, 100 m -80, 0 a 80,80 0 1,1 160,0 a 80,80 0 1,1 -160,0" fill="none" />
                                <text class="svg-text-path uppercase tracking-[0.3em] font-mono fill-current font-medium">
                                    <textPath href="#textPath" startOffset="0%">SYSTEM CALIBRATION • LIQUIDITY FLOW • SYSTEM CALIBRATION • LIQUIDITY FLOW • </textPath>
                                </text>
                            </svg>
                        </div>

                        <!-- Calibration Ticks -->
                        <div class="absolute inset-12 rounded-full border-[1px] border-dashed border-glass-400/40 animate-[spin_60s_linear_infinite_reverse]"></div>
                        
                        <!-- Inner Rings -->
                        <div class="absolute inset-20 rounded-full border border-glass-300/50 shadow-[inset_0_4px_20px_rgba(255,255,255,0.6)] flex items-center justify-center bg-white/40 backdrop-blur-md">
                            <!-- Center Emblem -->
                            <div class="w-20 h-20 rounded-full bg-gradient-to-tr from-glass-100 to-white shadow-sm border border-white flex items-center justify-center relative group cursor-pointer">
                                <div class="absolute inset-0 rounded-full border border-water-300/0 group-hover:border-water-300/100 transition-colors duration-500 scale-110"></div>
                                <iconify-icon icon="solar:tuning-square-linear" class="text-glass-900 text-3xl group-hover:rotate-90 transition-transform duration-700" stroke-width="1.5"></iconify-icon>
                            </div>
                        </div>

                        <!-- Indicator Dots -->
                        <div class="absolute top-8 left-1/2 -translate-x-1/2 w-1 h-1 bg-glass-900 rounded-full"></div>
                        <div class="absolute bottom-8 left-1/2 -translate-x-1/2 w-1 h-1 bg-glass-900 rounded-full"></div>
                        <div class="absolute left-8 top-1/2 -translate-y-1/2 w-1 h-1 bg-glass-900 rounded-full"></div>
                        <div class="absolute right-8 top-1/2 -translate-y-1/2 w-1 h-1 bg-glass-900 rounded-full"></div>

                    </div>
                </div>
            </div>
        </div>

        <!-- Logos Array -->
        <div class="w-full max-w-5xl mt-32 border-y border-glass-300/30 py-8 hero-reveal flex flex-wrap justify-center items-center gap-12 md:gap-24 opacity-60 mix-blend-multiply">
            <iconify-icon icon="simple-icons:nasa" class="text-glass-900" width="64" height="64"></iconify-icon>
            <iconify-icon icon="simple-icons:spacex" class="text-glass-900" width="64" height="64"></iconify-icon>
            <iconify-icon icon="simple-icons:uber" class="text-glass-900" width="64" height="64"></iconify-icon>
            <iconify-icon icon="simple-icons:sony" class="text-glass-900" width="64" height="64"></iconify-icon>
            <iconify-icon icon="simple-icons:nikon" class="text-glass-900" width="64" height="64"></iconify-icon>
        </div>

        <!-- Features Grid (Instrument Modules) -->
        <div class="grid grid-cols-1 md:grid-cols-3 gap-6 w-full mt-24 relative feature-grid max-w-6xl">
            
            <!-- Module 1 -->
            <div class="feature-card relative group p-[1px] rounded-2xl bg-gradient-to-br from-white via-glass-200 to-glass-300 shadow-sm hover:shadow-md transition-shadow">
                <div class="bg-white/50 backdrop-blur-xl rounded-2xl h-full p-8 flex flex-col relative z-10 border border-white/60">
                    <div class="flex items-center justify-between mb-8 border-b border-glass-300/40 pb-4">
                        <iconify-icon icon="solar:routing-2-linear" class="text-glass-900 text-2xl" stroke-width="1.5"></iconify-icon>
                        <span class="text-xs font-mono text-glass-400 uppercase tracking-widest">Mod_01</span>
                    </div>
                    <h3 class="text-sm font-semibold text-glass-900 tracking-wide uppercase mb-3">Fluid Routing</h3>
                    <p class="text-xs text-glass-500 font-normal leading-relaxed mb-10">
                        Navigate the cleanest execution paths across unified pools, circumventing high-turbulence volatility.
                    </p>
                    
                    <div class="mt-auto relative bg-glass-50/80 border border-glass-200 p-4 rounded-lg shadow-inner">
                        <div class="flex justify-between items-center mb-4 font-mono text-xs text-glass-500 uppercase tracking-wider">
                            <span>Path</span>
                            <span class="text-water-500">Active</span>
                        </div>
                        <div class="space-y-2 border-l border-glass-300 pl-3 font-mono text-xs">
                            <p class="text-glass-400">Node_A <span class="text-glass-900 ml-2">Clear</span></p>
                            <p class="text-glass-400">Node_B <span class="text-glass-900 ml-2">Clear</span></p>
                            <div class="h-1 w-full bg-glass-200 rounded-full mt-3 overflow-hidden">
                                <div class="h-full w-3/4 bg-glass-900 rounded-full relative">
                                    <div class="absolute inset-0 bg-white/20 animate-pulse"></div>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Module 2 (Dial focus) -->
            <div class="feature-card relative group md:-translate-y-8 p-[1px] rounded-2xl bg-gradient-to-br from-white via-water-100 to-glass-200 shadow-sm hover:shadow-md transition-shadow">
                <div class="bg-white/60 backdrop-blur-xl rounded-2xl h-full p-8 flex flex-col relative z-10 border border-white">
                    <div class="flex items-center justify-between mb-8 border-b border-glass-300/40 pb-4">
                        <iconify-icon icon="solar:scale-linear" class="text-water-500 text-2xl" stroke-width="1.5"></iconify-icon>
                        <span class="text-xs font-mono text-glass-400 uppercase tracking-widest">Mod_02</span>
                    </div>
                    <h3 class="text-sm font-semibold text-glass-900 tracking-wide uppercase mb-3">Pressure Control</h3>
                    <p class="text-xs text-glass-500 font-normal leading-relaxed mb-8">
                        Adjust calibration parameters smoothly. Cryptographic stability thresholds built for high depth.
                    </p>
                    
                    <div class="mt-auto flex flex-col gap-4">
                        <div class="flex justify-between items-center font-mono text-xs text-glass-500 uppercase tracking-widest">
                            <span>Threshold</span>
                            <span class="text-glass-900 font-semibold">84%</span>
                        </div>
                        <!-- Custom Instrument Slider -->
                        <div class="w-full relative px-1 py-4 flex items-center">
                            <!-- Calibration ticks for slider -->
                            <div class="absolute w-full flex justify-between px-2 -top-2">
                                <div class="w-[1px] h-2 bg-glass-400"></div>
                                <div class="w-[1px] h-1 bg-glass-300"></div>
                                <div class="w-[1px] h-2 bg-glass-400"></div>
                                <div class="w-[1px] h-1 bg-glass-300"></div>
                                <div class="w-[1px] h-2 bg-glass-400"></div>
                            </div>
                            <input type="range" min="0" max="100" value="84">
                        </div>
                    </div>
                </div>
            </div>

            <!-- Module 3 -->
            <div class="feature-card relative group p-[1px] rounded-2xl bg-gradient-to-br from-white via-glass-200 to-glass-300 shadow-sm hover:shadow-md transition-shadow">
                <div class="bg-white/50 backdrop-blur-xl rounded-2xl h-full p-8 flex flex-col relative z-10 border border-white/60">
                    <div class="flex items-center justify-between mb-8 border-b border-glass-300/40 pb-4">
                        <iconify-icon icon="solar:graph-up-linear" class="text-glass-900 text-2xl" stroke-width="1.5"></iconify-icon>
                        <span class="text-xs font-mono text-glass-400 uppercase tracking-widest">Mod_03</span>
                    </div>
                    <h3 class="text-sm font-semibold text-glass-900 tracking-wide uppercase mb-3">Yield Dynamics</h3>
                    <p class="text-xs text-glass-500 font-normal leading-relaxed mb-10">
                        Extract base value from hidden low-visibility environments previously obscured by standard tooling.
                    </p>
                    
                    <div class="mt-auto relative bg-glass-50/80 border border-glass-200 p-4 rounded-lg shadow-inner flex justify-center items-center">
                        <div class="relative w-24 h-24 rounded-full border border-glass-300 flex items-center justify-center bg-white shadow-sm">
                            <div class="absolute inset-2 border border-dashed border-glass-400/50 rounded-full animate-[spin_20s_linear_infinite]"></div>
                            <span class="text-lg font-serif text-glass-900 tracking-tight">4.2<span class="text-xs font-mono text-glass-400 ml-1">APY</span></span>
                        </div>
                    </div>
                </div>
            </div>
        </div>

    </main>

    <!-- Secondary Statement Section with Masked Reveal -->
    <section class="relative w-full border-t border-glass-300/30 bg-white/40 backdrop-blur-lg pt-32 pb-40 overflow-hidden mt-24">
        <div class="relative z-10 w-full max-w-5xl mx-auto px-4 md:px-8">
            
            <!-- Frame for Statement -->
            <div class="relative border-l border-glass-400/30 pl-6 md:pl-12 py-4">
                <div class="absolute -top-4 -left-[1.5px] w-3 h-3 border-t border-l border-glass-400/60"></div>
                <div class="absolute -bottom-4 -left-[1.5px] w-3 h-3 border-b border-l border-glass-400/60"></div>
                
                <div class="flex items-center gap-4 mb-10">
                    <div class="w-8 h-[1px] bg-glass-400"></div>
                    <span class="text-xs tracking-[0.3em] uppercase text-glass-500 font-mono font-medium">Fluid Logic</span>
                </div>

                <h2 id="statement-text" class="font-serif text-4xl md:text-6xl tracking-tight leading-[1.1] max-w-3xl text-glass-900">
                    The modern operator orchestrates the current. Through instrumented precision and absolute transparency, <span class="italic text-glass-500 font-normal">complexity becomes clarity.</span>
                </h2>
            </div>

            <!-- Footer / Calibration Signature -->
            <div class="mt-32 w-full flex justify-between items-end border-t border-glass-300/30 pt-8 font-mono text-xs uppercase tracking-widest text-glass-400">
                <div class="flex items-center gap-2">
                    <div class="w-2 h-2 border border-glass-400 rounded-full flex items-center justify-center">
                        <div class="w-[1px] h-[1px] bg-glass-900"></div>
                    </div>
                    <span>SYS_ONLINE</span>
                </div>
                <span>© Fluid_OS</span>
            </div>

        </div>
    </section>

    <script>
        // --- WebGL Background setup (Light Sea Caustics Simulation) ---
        const canvas = document.querySelector('#webgl-canvas');
        const renderer = new THREE.WebGLRenderer({ canvas, alpha: true, antialias: false });
        renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
        
        const scene = new THREE.Scene();
        const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
        const geometry = new THREE.PlaneGeometry(2, 2);
        
        const material = new THREE.ShaderMaterial({
            uniforms: {
                uTime: { value: 0 },
                uResolution: { value: new THREE.Vector2() }
            },
            vertexShader: `
                varying vec2 vUv;
                void main() {
                    vUv = uv;
                    gl_Position = vec4(position, 1.0);
                }
            `,
            fragmentShader: `
                uniform float uTime;
                uniform vec2 uResolution;
                varying vec2 vUv;

                // Simplex noise function
                vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
                vec2 mod289(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
                vec3 permute(vec3 x) { return mod289(((x*34.0)+1.0)*x); }
                float snoise(vec2 v) {
                    const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
                    vec2 i  = floor(v + dot(v, C.yy) );
                    vec2 x0 = v -   i + dot(i, C.xx);
                    vec2 i1;
                    i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
                    vec4 x12 = x0.xyxy + C.xxzz;
                    x12.xy -= i1;
                    i = mod289(i);
                    vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) + i.x + vec3(0.0, i1.x, 1.0 ));
                    vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
                    m = m*m ;
                    m = m*m ;
                    vec3 x = 2.0 * fract(p * C.www) - 1.0;
                    vec3 h = abs(x) - 0.5;
                    vec3 ox = floor(x + 0.5);
                    vec3 a0 = x - ox;
                    m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
                    vec3 g;
                    g.x  = a0.x  * x0.x  + h.x  * x0.y;
                    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
                    return 130.0 * dot(m, g);
                }

                void main() {
                    vec2 st = gl_FragCoord.xy / uResolution.xy;
                    st.x *= uResolution.x / uResolution.y;

                    // Light Instrument Panel Water Base
                    vec3 baseColor = vec3(0.96, 0.98, 1.0); 
                    
                    // Slow, rippling liquid movement
                    vec2 pos = vec2(st * 3.0);
                    float n1 = snoise(pos + uTime * 0.04);
                    float n2 = snoise(pos + vec2(uTime * 0.03, -uTime * 0.05));
                    float n3 = snoise(pos * 0.6 - uTime * 0.02);

                    // Light fluid highlights (caustics feel)
                    vec3 highlight1 = vec3(1.0, 1.0, 1.0); // Bright white crests
                    vec3 highlight2 = vec3(0.88, 0.95, 1.0); // Very light cyan depths

                    vec3 color = baseColor;
                    
                    // Create thin caustic-like bands
                    float caustic = smoothstep(0.7, 0.9, sin(n1 * 10.0)) * 0.5;
                    color += highlight1 * caustic;
                    
                    // Add soft depth shadows
                    color = mix(color, highlight2, smoothstep(0.2, 0.8, n2) * 0.6);
                    color -= vec3(0.02) * smoothstep(0.0, 1.0, n3);

                    // Soft vignette framing
                    float dist = distance(st, vec2(0.5 * uResolution.x/uResolution.y, 0.5));
                    color = mix(color, vec3(0.94, 0.96, 0.98), smoothstep(0.8, 1.5, dist));

                    gl_FragColor = vec4(color, 1.0);
                }
            `
        });

        const mesh = new THREE.Mesh(geometry, material);
        scene.add(mesh);

        function resize() {
            renderer.setSize(window.innerWidth, window.innerHeight);
            material.uniforms.uResolution.value.set(window.innerWidth, window.innerHeight);
        }
        window.addEventListener('resize', resize);
        resize();

        function animate(time) {
            material.uniforms.uTime.value = time * 0.001;
            renderer.render(scene, camera);
            requestAnimationFrame(animate);
        }
        requestAnimationFrame(animate);

        // --- GSAP Animations ---
        gsap.registerPlugin(ScrollTrigger);

        // Hero Reveal
        gsap.from(".hero-reveal", {
            y: 20,
            opacity: 0,
            duration: 1.2,
            stagger: 0.2,
            ease: "power2.out",
            delay: 0.1
        });

        // Feature Cards Entry
        gsap.from(".feature-card", {
            scrollTrigger: {
                trigger: ".feature-grid",
                start: "top 85%",
            },
            y: 30,
            opacity: 0,
            duration: 1,
            stagger: 0.1,
            ease: "power1.out"
        });

        // Masked Word Reveal Logic
        const textElement = document.getElementById('statement-text');
        
        function wrapWordsPreservingHTML(element) {
            const nodes = Array.from(element.childNodes);
            element.innerHTML = '';
            
            nodes.forEach(node => {
                if (node.nodeType === 3) {
                    const words = node.nodeValue.split(/\s+/).filter(w => w.length > 0);
                    words.forEach(word => {
                        const outer = document.createElement('span');
                        outer.className = 'masked-word mr-[0.25em]';
                        const inner = document.createElement('span');
                        inner.className = 'masked-word-inner';
                        inner.textContent = word;
                        outer.appendChild(inner);
                        element.appendChild(outer);
                    });
                } else if (node.nodeType === 1) {
                    const clone = node.cloneNode(false);
                    wrapWordsPreservingHTML(node);
                    while(node.firstChild) {
                        clone.appendChild(node.firstChild);
                    }
                    element.appendChild(clone);
                }
            });
        }

        wrapWordsPreservingHTML(textElement);

        gsap.to("#statement-text .masked-word-inner", {
            scrollTrigger: {
                trigger: "#statement-text",
                start: "top 80%",
            },
            y: "0%",
            duration: 1.2,
            stagger: 0.015,
            ease: "power4.out"
        });

    </script>
</body>
</html>
";
    const assetFiles = [];
    const runtimeFiles = ["../../../../assets/runtime/runtime-027051effa47-gsap-min.js","../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js","../../../../assets/runtime/runtime-2f01c69cbd22-three-min.js","../../../../assets/runtime/runtime-689ca8dda44c-scrolltrigger-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/company-logos · 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 company-logos.zip