AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
The marquee-loop skill provides a structured approach to implementing infinite scrolling animations in web design. By duplicating content sequences and applying linear transforms, it ensures a smooth, continuous loop effect. The workflow emphasizes performance and accessibility, advising on item stability, edge masking, and respecting user motion preferences.
What it does
- Guides the duplication of content to ensure a seamless transition between the end and start of a loop.
- Defines the animation logic using linear transforms.
- Provides best practices for maintaining stable item widths to prevent visual jumps.
- Suggests techniques for masking or fading edges for a polished look.
- Includes accessibility considerations for reduced motion settings.
- Outlines performance guardrails to avoid CPU-heavy effects.
When to use it
- When implementing infinite scrolling carousels for logos or testimonials.
- When displaying short feature chips or tags in a continuous loop.
- When creating dynamic background elements that require seamless repetition.
- When you need to ensure animations remain performant and accessible.
Advantages
- Ensures visual continuity through a proven duplication workflow.
- Promotes accessible design by incorporating reduced motion support.
- Improves performance by discouraging heavy filters on moving elements.
- Provides clear steps for achieving a professional, glitch-free animation.
Usage examples
- “Create a seamless infinite marquee for a list of client logos.”
- The agent will guide you through duplicating the logo list, setting the linear transform to -50%, and applying edge masks for a smooth, continuous loop.
- “How do I make my testimonial slider loop without jumping?”
- The agent will instruct you to ensure consistent item widths and use the specified duplication technique to align the start and end points perfectly.
Install
3 of its files are not mirrored here, so install it from its source:
https://github.com/MengTo/Skills/tree/5ea1661a0e05d82b054553daaa6baf6d0233c33c/agent-skills/web-design/marquee-loop
Documentation by Meng To
Marquee Skill
Use When
A design needs a seamless infinite loop for logos, testimonials, screenshots, tags, or short feature chips.
Workflow
Duplicate the item sequence so the end and beginning match perfectly.
Animate the track with a linear transform from 0 to -50%.
Keep item widths stable to prevent jumps during the loop.
Mask or fade the edges when the marquee enters or exits a section.
Pause or slow the marquee on hover only when interaction is useful.
Respect prefers-reduced-motion with a static wrap or very slow movement.
Guardrails
Do not animate unique content that users must read carefully.
Do not use large CPU-heavy shadows or filters on every moving item.
Files
- ATTRIBUTION.mdAdded by AutoGineer846 B
- LICENSELicence file added by AutoGineer1.0 KiB
- SKILL.md818 B
- demo/PROMPT.md2.5 KiB
- demo/assets/page-01-6b97b0cc-6b81-4451-aacc-6b928e7d0a69-3840w.jpg(opens on GitHub)Not mirrored: opens on GitHub1.3 MiB
- demo/assets/page-02-193e1472-0514-44eb-893a-1376091263f3-3840w.jpg(opens on GitHub)Not mirrored: opens on GitHub1.0 MiB
- demo/assets/page-03-5180d964-2425-4134-8220-c1528af09124-800w.jpg53.8 KiB
- demo/assets/page-04-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-1600w.jpg212.3 KiB
- demo/assets/page-05-fbddf75f-e2e3-4552-a710-55e2a5f4d6af-800w.jpg33.0 KiB
- demo/assets/page-06-16d38370-5873-45cf-bab1-60a7b923dc6e-800w.jpg56.4 KiB
- demo/assets/page-07-8e802a98-b83c-4c5d-99d1-e24406eb4ec9-3840w.jpg(opens on GitHub)Not mirrored: opens on GitHub2.2 MiB
- demo/assets/source-preview.jpg120.0 KiB
- demo/index.html28.9 KiB
- demo/preview.jpg114.2 KiB
- demo/source.json4.4 KiB
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>Landing Page</title>
    <script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
    <script src="../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js"></script>
    <script src="../../../../assets/runtime/runtime-027051effa47-gsap-min.js"></script>
    <script src="../../../../assets/runtime/runtime-689ca8dda44c-scrolltrigger-min.js"></script>
    <style>
        /* Grain overlay for images to match reference texture */
        .texture-overlay {
            background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 200 200' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='noiseFilter'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.85' numOctaves='3' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23noiseFilter)' opacity='0.15'/%3E%3C/svg%3E");
            pointer-events: none;
        }
        
        /* Subtle diagonal background lines for Framed Grid Layout */
        .bg-diagonal {
            background-image: repeating-linear-gradient(45deg, rgba(0,0,0,0.02) 0px, rgba(0,0,0,0.02) 1px, transparent 1px, transparent 10px);
        }

        /* Seamless infinite marquee loop */
        @keyframes marquee {
            0% { transform: translateX(0%); }
            100% { transform: translateX(-50%); }
        }
        .animate-marquee {
            display: flex;
            animation: marquee 25s linear infinite;
        }
    </style>
</head>
<body class="bg-[#e7e7e7] bg-diagonal min-h-screen flex items-center justify-center p-6 md:p-12 antialiased text-zinc-900 font-sans selection:bg-zinc-300 selection:text-black">

    <!-- Framed Grid Layout Container -->
    <main class="relative w-full max-w-7xl mx-auto border border-zinc-300/60 p-6 md:p-10 bg-[#e7e7e7]/50 backdrop-blur-sm">
        
        <!-- L-shaped corner brackets -->
        <div class="absolute -top-[1px] -left-[1px] w-5 h-5 border-t-2 border-l-2 border-zinc-400"></div>
        <div class="absolute -top-[1px] -right-[1px] w-5 h-5 border-t-2 border-r-2 border-zinc-400"></div>
        <div class="absolute -bottom-[1px] -left-[1px] w-5 h-5 border-b-2 border-l-2 border-zinc-400"></div>
        <div class="absolute -bottom-[1px] -right-[1px] w-5 h-5 border-b-2 border-r-2 border-zinc-400"></div>

        <!-- Marquee Header -->
        <div class="border-b border-zinc-300/60 mb-6 md:mb-10 pb-4 overflow-hidden relative flex select-none">
            <div class="animate-marquee flex whitespace-nowrap">
                <!-- Group 1 -->
                <div class="flex items-center gap-8 px-4 text-xs uppercase tracking-widest text-zinc-500 font-normal">
                    <span>lumina.studio</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>digital architecture</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>user experience</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>visual systems</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>lumina.studio</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>digital architecture</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>user experience</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>visual systems</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                </div>
                <!-- Group 2 (Duplicate for seamless loop) -->
                <div class="flex items-center gap-8 px-4 text-xs uppercase tracking-widest text-zinc-500 font-normal">
                    <span>lumina.studio</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>digital architecture</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>user experience</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>visual systems</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>lumina.studio</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>digital architecture</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>user experience</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                    <span>visual systems</span>
                    <div class="w-1 h-1 rounded-full bg-zinc-300"></div>
                </div>
            </div>
        </div>

        <div class="grid grid-cols-1 lg:grid-cols-3 gap-4 md:gap-6">

            <!-- Card 1 (Previously Card 3) -->
            <div class="relative rounded-2xl bg-gradient-to-b from-white/10 to-transparent p-[1px] shadow-[0_2.8px_2.2px_rgba(0,_0,_0,_0.034),_0_6.7px_5.3px_rgba(0,_0,_0,_0.048),_0_12.5px_10px_rgba(0,_0,_0,_0.06),_0_22.3px_17.9px_rgba(0,_0,_0,_0.072),_0_41.8px_33.4px_rgba(0,_0,_0,_0.086),_0_100px_80px_rgba(0,_0,_0,_0.12)]">
                <div class="flex h-full flex-col overflow-hidden rounded-[15px] bg-[#111111]">
                    <div class="relative h-64 w-full md:h-72 shrink-0">
                        <img src="assets/page-01-6b97b0cc-6b81-4451-aacc-6b928e7d0a69-3840w.jpg" alt="Coastline landscape" class="h-full w-full object-cover grayscale contrast-[1.2] brightness-75">
                        <div class="absolute inset-0 texture-overlay mix-blend-overlay"></div>
                        
                        <!-- Overlay: UI Card -->
                        <div class="absolute inset-0 flex items-center justify-center p-6">
                            <div class="w-full max-w-[260px] rounded-xl bg-white p-4 shadow-[0px_2px_3px_-1px_rgba(0,0,0,0.1),0px_1px_0px_0px_rgba(25,28,33,0.02),0px_0px_0px_1px_rgba(25,28,33,0.08)] ring-1 ring-black/5">
                                <div class="flex items-center justify-between mb-4">
                                    <span class="text-sm font-medium tracking-tight text-zinc-900">Product &amp; App</span>
                                    <div class="flex gap-0.5 opacity-40">
                                        <div class="w-[3px] h-[3px] rounded-full bg-black"></div>
                                        <div class="w-[3px] h-[3px] rounded-full bg-black"></div>
                                        <div class="w-[3px] h-[3px] rounded-full bg-black"></div>
                                    </div>
                                </div>
                                
                                <div class="mb-4 rounded-lg bg-zinc-100/80 p-3 ring-1 ring-black/5">
                                    <div class="flex items-center justify-between text-xs text-zinc-400 mb-2">
                                        <div class="flex items-center gap-1.5 font-normal">
                                            <iconify-icon icon="solar:clock-circle-linear" class="text-sm"></iconify-icon>
                                            Project process
                                        </div>
                                        <span class="font-medium text-zinc-900">92%</span>
                                    </div>
                                    <div class="h-1.5 w-full rounded-full bg-zinc-200 overflow-hidden">
                                        <div class="h-full w-[92%] bg-zinc-300 rounded-full"></div>
                                    </div>
                                </div>
                                
                                <div class="flex flex-col gap-2 pt-1 text-xs">
                                    <div class="text-zinc-400 font-normal">Updates</div>
                                    <div class="flex justify-between items-center">
                                        <span class="text-zinc-400">Last</span>
                                        <span class="font-normal text-zinc-900">Oct 04, 2025</span>
                                    </div>
                                    <div class="flex justify-between items-center">
                                        <span class="text-zinc-400">Next</span>
                                        <span class="font-normal text-zinc-900">Oct 09, 2025</span>
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>
                    <div class="flex flex-1 flex-col justify-between p-6 md:p-8">
                        <div>
                            <div class="flex items-center gap-2">
                                <div class="h-2.5 w-[2px] bg-zinc-400"></div>
                                <span class="text-xs uppercase tracking-wider text-zinc-400 font-normal">Research · Design · Build · Launch</span>
                            </div>
                            <h2 class="gs-reveal mt-5 text-xl md:text-2xl font-medium tracking-tight text-white leading-[1.15]">
                                Your product is your promise. Ensure it delivers on every interaction.
                            </h2>
                            <p class="mt-4 text-xs md:text-sm text-zinc-400 leading-relaxed font-light pr-4">
                                We engineer platforms that perform flawlessly when the stakes are highest.
                            </p>
                        </div>
                        <div class="mt-8 text-xs text-zinc-600 font-normal">lumina.studio</div>
                    </div>
                </div>
            </div>

            <!-- Card 2 (Previously Card 1) -->
            <div class="relative rounded-2xl bg-gradient-to-b from-white/10 to-transparent p-[1px] shadow-[0_2.8px_2.2px_rgba(0,_0,_0,_0.034),_0_6.7px_5.3px_rgba(0,_0,_0,_0.048),_0_12.5px_10px_rgba(0,_0,_0,_0.06),_0_22.3px_17.9px_rgba(0,_0,_0,_0.072),_0_41.8px_33.4px_rgba(0,_0,_0,_0.086),_0_100px_80px_rgba(0,_0,_0,_0.12)]">
                <div class="flex h-full flex-col overflow-hidden rounded-[15px] bg-[#111111]">
                    <div class="relative h-64 w-full md:h-72 shrink-0">
                        <img src="assets/page-02-193e1472-0514-44eb-893a-1376091263f3-3840w.jpg" alt="Rugged landscape" class="h-full w-full object-cover grayscale contrast-[1.2] brightness-75">
                        <div class="absolute inset-0 texture-overlay mix-blend-overlay"></div>
                        
                        <!-- Overlay: Avatars -->
                        <div class="absolute inset-0 flex items-center justify-center">
                            <div class="flex -space-x-2 shadow-[0px_2px_3px_-1px_rgba(0,0,0,0.1),0px_1px_0px_0px_rgba(25,28,33,0.02),0px_0px_0px_1px_rgba(25,28,33,0.08)] rounded-full p-1 bg-white/5 backdrop-blur-sm">
                                <img class="inline-block h-10 w-10 rounded-full ring-2 ring-[#111] grayscale object-cover" src="assets/page-03-5180d964-2425-4134-8220-c1528af09124-800w.jpg" alt="Avatar">
                                <img class="inline-block h-10 w-10 rounded-full ring-2 ring-[#111] grayscale object-cover" src="assets/page-04-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-1600w.jpg" alt="Avatar">
                                <img class="inline-block h-10 w-10 rounded-full ring-2 ring-[#111] grayscale object-cover" src="assets/page-05-fbddf75f-e2e3-4552-a710-55e2a5f4d6af-800w.jpg" alt="Avatar">
                                <img class="inline-block h-10 w-10 rounded-full ring-2 ring-[#111] grayscale object-cover" src="assets/page-06-16d38370-5873-45cf-bab1-60a7b923dc6e-800w.jpg" alt="Avatar">
                                <div class="flex h-10 w-10 items-center justify-center rounded-full bg-[#e7e7e7] ring-2 ring-[#111] text-xs font-medium tracking-tight text-black">40+</div>
                            </div>
                        </div>
                    </div>
                    <div class="flex flex-1 flex-col justify-between p-6 md:p-8">
                        <div>
                            <div class="flex items-center gap-2">
                                <div class="h-2.5 w-[2px] bg-zinc-400"></div>
                                <span class="text-xs uppercase tracking-wider text-zinc-400 font-normal">Crafted with precision. Shipped with confidence.</span>
                            </div>
                            <h2 class="gs-reveal mt-5 text-xl md:text-2xl font-medium tracking-tight text-white leading-[1.15]">
                                Chosen by visionaries who demand excellence in every pixel.
                            </h2>
                            <p class="mt-4 text-xs md:text-sm text-zinc-400 leading-relaxed font-light pr-4">
                                Brilliant idea. Execution that falls short. We bridge that gap and ensure it stays closed.
                            </p>
                        </div>
                        <div class="mt-8 text-xs text-zinc-600 font-normal">lumina.studio</div>
                    </div>
                </div>
            </div>

            <!-- Card 3 (Previously Card 2) -->
            <div class="relative rounded-2xl bg-gradient-to-b from-white/10 to-transparent p-[1px] shadow-[0_2.8px_2.2px_rgba(0,_0,_0,_0.034),_0_6.7px_5.3px_rgba(0,_0,_0,_0.048),_0_12.5px_10px_rgba(0,_0,_0,_0.06),_0_22.3px_17.9px_rgba(0,_0,_0,_0.072),_0_41.8px_33.4px_rgba(0,_0,_0,_0.086),_0_100px_80px_rgba(0,_0,_0,_0.12)]">
                <div class="flex h-full flex-col overflow-hidden rounded-[15px] bg-[#111111]">
                    <div class="relative h-64 w-full md:h-72 shrink-0">
                        <img src="assets/page-07-8e802a98-b83c-4c5d-99d1-e24406eb4ec9-3840w.jpg" alt="Vast landscape" class="h-full w-full object-cover grayscale contrast-[1.2] brightness-90">
                        <div class="absolute inset-0 texture-overlay mix-blend-overlay opacity-70"></div>
                    </div>
                    <div class="flex flex-1 flex-col justify-between p-6 md:p-8">
                        <div class="mt-8">
                            <h2 class="gs-reveal text-xl md:text-2xl font-medium tracking-tight text-white leading-[1.15]">
                                The engine powering the experience.
                            </h2>
                            <p class="mt-4 text-xs md:text-sm text-zinc-400 leading-relaxed font-light pr-4">
                                Digital architecture, user experience, and visual systems built from the ground up. Unified and deliberate.
                            </p>
                        </div>
                        <div class="mt-8 text-xs text-zinc-600 font-normal opacity-0 select-none">lumina.studio</div>
                    </div>
                </div>
            </div>

        </div>
    </main>

    <script>
        document.addEventListener("DOMContentLoaded", () => {
            gsap.registerPlugin(ScrollTrigger);

            const revealElements = document.querySelectorAll(".gs-reveal");

            revealElements.forEach((elem) => {
                const text = elem.innerText;
                elem.innerHTML = "";
                
                // Split text by words
                const words = text.split(" ");
                
                words.forEach((word, index) => {
                    // Create outer mask container
                    const wordWrapper = document.createElement("span");
                    wordWrapper.style.display = "inline-block";
                    wordWrapper.style.overflow = "hidden";
                    wordWrapper.style.verticalAlign = "top";
                    
                    // Create inner animated span
                    const wordSpan = document.createElement("span");
                    wordSpan.style.display = "inline-block";
                    wordSpan.style.transform = "translateY(100%)";
                    wordSpan.style.opacity = "0";
                    wordSpan.innerHTML = word;
                    
                    wordWrapper.appendChild(wordSpan);
                    elem.appendChild(wordWrapper);

                    // Add space after word unless it's the last one
                    if (index < words.length - 1) {
                        const space = document.createTextNode(" ");
                        elem.appendChild(space);
                    }
                });

                // Animate words
                gsap.to(elem.querySelectorAll("span > span"), {
                    scrollTrigger: {
                        trigger: elem,
                        start: "top 90%",
                    },
                    y: "0%",
                    opacity: 1,
                    duration: 0.7,
                    stagger: 0.02,
                    ease: "power3.out"
                });
            });
        });
    </script>

</body>
</html>
";
const assetFiles = ["assets/page-01-6b97b0cc-6b81-4451-aacc-6b928e7d0a69-3840w.jpg","assets/page-02-193e1472-0514-44eb-893a-1376091263f3-3840w.jpg","assets/page-03-5180d964-2425-4134-8220-c1528af09124-800w.jpg","assets/page-04-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-1600w.jpg","assets/page-05-fbddf75f-e2e3-4552-a710-55e2a5f4d6af-800w.jpg","assets/page-06-16d38370-5873-45cf-bab1-60a7b923dc6e-800w.jpg","assets/page-07-8e802a98-b83c-4c5d-99d1-e24406eb4ec9-3840w.jpg"];
const runtimeFiles = ["../../../../assets/runtime/runtime-027051effa47-gsap-min.js","../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-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/marquee-loop · 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.
Get it from the source
3 of this skill’s files are not mirrored here, so there is no ZIP. Get the complete skill from its source: MengTo/Skills