AutoGineer
Generated banner for Webgl 3d Object
Generated logo for Webgl 3d Object

Webgl 3d Object

Meng ToCommunityCreated by Meng To

  • Skill
  • Tool integration
  • Software development
  • MIT
  • Medium risk
Download ZIP

From the author

Create a real 3D WebGL object with geometric mesh depth, physically based material, directional and ambient lighting, perspective camera, subtle rotation, and floating motion. Use when a page needs a faceted 3D hero object or product-like visual with real lighting instead of CSS transform tricks.
— the description by Meng To

AutoGineer summary

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

This skill provides a structured approach to integrating 3D WebGL objects into web interfaces using Three.js. It focuses on creating geometric meshes with physically based rendering (PBR) materials, directional lighting, and subtle animation. The implementation includes a robust setup for handling canvas resizing, performance-conscious rendering, and proper memory management through object disposal.

What it does

  • Initializes a Three.js scene with a perspective camera and WebGL renderer.
  • Configures PBR materials using metalness, roughness, and emissive properties.
  • Sets up multi-point lighting including directional and ambient sources.
  • Implements subtle rotation and floating animations for 3D meshes.
  • Handles window resizing and cleanup of geometry, materials, and renderers.
  • Supports reduced motion preferences for accessibility.

When to use it

  • When a web page requires a 3D hero object or product visual.
  • When real geometric depth and lighting are preferred over CSS-based illusions.
  • When you need a faceted or custom mesh that responds to light sources.
  • When building feature blocks that benefit from subtle, continuous motion.

Advantages

  • Provides a clean, modular recipe for Three.js integration.
  • Includes built-in memory management to prevent leaks.
  • Ensures consistent rendering across different device pixel ratios.
  • Offers clear guidelines for material and lighting configurations.

Usage examples

“Create a metallic 3D hero object for my product page.”
The agent provides the Three.js initialization code with MeshStandardMaterial configured for a metallic look, including directional lighting and a shadow plane.
“How do I make my 3D object look like soft ceramic?”
The agent advises adjusting the material properties to low metalness (0.0-0.15) and moderate roughness (0.38-0.62) within the provided Three.js template.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/mengto/webgl-3d-object/download

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

    mkdir -p .agents/skills && unzip webgl-3d-object.zip -d .agents/skills

Documentation by Meng To

WebGL 3D Object

Use When

  • A hero, feature block, or product moment needs one strong 3D object.

  • The visual should show real geometry, lighting, highlights, and edges.

  • A faceted mesh should float or rotate subtly inside a web layout.

  • CSS transforms, SVG illusions, or flat gradients are not enough.

Rules

  1. Use real 3D geometry: IcosahedronGeometry, DodecahedronGeometry, BoxGeometry, custom BufferGeometry, or a glTF mesh.

  2. Use a perspective camera so the object has depth and scale.

  3. Use PBR material: MeshStandardMaterial or MeshPhysicalMaterial.

  4. Tune metalness, roughness, and emissive to match the brand mood.

  5. Light the object with at least one directional light plus ambient or hemisphere fill.

  6. Animate transforms only: subtle rotation, bobbing, or parallax.

  7. Handle resize and dispose geometry/material/renderer on teardown.

HTML And CSS

<div class="webgl-object-shell">
  <canvas class="webgl-object-canvas" data-webgl-3d-object></canvas>
</div>
.webgl-object-shell {
  position: relative;
  width: min(100%, 720px);
  aspect-ratio: 1 / 1;
}

.webgl-object-canvas {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  display: block;
}

Three.js Object Recipe

import * as THREE from "three";

function initWebGL3DObject(canvas, options = {}) {
  if (!canvas) return () => {};

  const renderer = new THREE.WebGLRenderer({
    canvas,
    antialias: true,
    alpha: true,
  });
  renderer.setClearColor(0x000000, 0);
  renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, options.maxDpr || 1.75));
  renderer.outputColorSpace = THREE.SRGBColorSpace;
  renderer.toneMapping = THREE.ACESFilmicToneMapping;
  renderer.toneMappingExposure = options.exposure || 1.05;
  renderer.shadowMap.enabled = true;
  renderer.shadowMap.type = THREE.PCFSoftShadowMap;

  const scene = new THREE.Scene();
  const camera = new THREE.PerspectiveCamera(38, 1, 0.1, 100);
  camera.position.set(0, 0.15, 5.2);

  const geometry = new THREE.IcosahedronGeometry(options.radius || 1.35, options.detail || 1);
  const material = new THREE.MeshStandardMaterial({
    color: options.color || 0x8aa4ff,
    metalness: options.metalness ?? 0.48,
    roughness: options.roughness ?? 0.34,
    emissive: options.emissive || 0x101833,
    emissiveIntensity: options.emissiveIntensity ?? 0.22,
    flatShading: true,
  });

  const object = new THREE.Mesh(geometry, material);
  object.castShadow = true;
  object.receiveShadow = true;
  scene.add(object);

  const ambient = new THREE.AmbientLight(0xffffff, 0.38);
  scene.add(ambient);

  const key = new THREE.DirectionalLight(0xffffff, 2.15);
  key.position.set(3.4, 4.2, 4.8);
  key.castShadow = true;
  key.shadow.mapSize.set(1024, 1024);
  scene.add(key);

  const rim = new THREE.DirectionalLight(options.rimColor || 0x7dd3fc, 0.82);
  rim.position.set(-4.2, 1.2, -2.8);
  scene.add(rim);

  const shadowPlane = new THREE.Mesh(
    new THREE.PlaneGeometry(5.2, 5.2),
    new THREE.ShadowMaterial({ opacity: 0.18 })
  );
  shadowPlane.position.set(0, -1.65, 0);
  shadowPlane.rotation.x = -Math.PI / 2;
  shadowPlane.receiveShadow = true;
  scene.add(shadowPlane);

  const reduceMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
  let rafId = 0;

  function resize() {
    const width = Math.max(1, canvas.clientWidth);
    const height = Math.max(1, canvas.clientHeight);
    renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, options.maxDpr || 1.75));
    renderer.setSize(width, height, false);
    camera.aspect = width / height;
    camera.updateProjectionMatrix();
  }

  function render(time = 0) {
    const t = time * 0.001;
    object.rotation.x = -0.16 + Math.sin(t * 0.45) * 0.06;
    object.rotation.y = t * 0.28;
    object.rotation.z = Math.sin(t * 0.32) * 0.08;
    object.position.y = reduceMotion ? 0 : Math.sin(t * 0.8) * 0.08;

    renderer.render(scene, camera);
    if (!reduceMotion) rafId = requestAnimationFrame(render);
  }

  function handleResize() {
    cancelAnimationFrame(rafId);
    resize();
    render();
  }

  resize();
  render();
  window.addEventListener("resize", handleResize);

  return () => {
    cancelAnimationFrame(rafId);
    window.removeEventListener("resize", handleResize);
    geometry.dispose();
    material.dispose();
    shadowPlane.geometry.dispose();
    shadowPlane.material.dispose();
    renderer.dispose();
  };
}

const cleanupObject = initWebGL3DObject(
  document.querySelector("[data-webgl-3d-object]"),
  {
    color: 0x8aa4ff,
    rimColor: 0x7dd3fc,
    metalness: 0.48,
    roughness: 0.34,
    emissive: 0x101833,
  }
);

Material Defaults

  • Premium metal: metalness: 0.45-0.7, roughness: 0.25-0.45.

  • Soft ceramic: metalness: 0.0-0.15, roughness: 0.38-0.62.

  • Glow-tinted tech object: low emissive with emissiveIntensity: 0.12-0.35.

  • Faceted object: set flatShading: true; smooth product object: set it to false.

Lighting Defaults

  • Key light: directional, high front-side angle, strongest source.

  • Ambient fill: low intensity so shadows stay visible.

  • Rim light: brand-tinted or cool light from behind to reveal edges.

  • Shadows: enable only when the object needs grounded depth; keep map size moderate.

Motion Defaults

  • Rotation: slow, continuous, and secondary to the page content.

  • Floating: 0.04 to 0.12 units on Y.

  • Reduced motion: render a still frame or only allow direct interaction.

  • Avoid camera movement unless the object is the main interaction.

Avoid

  • CSS 3D transforms pretending to be WebGL.

  • Unlit materials when the ask is real lighting and depth.

  • Flat planes with gradients instead of actual geometry.

  • Strong bloom or particles that hide the form.

  • High DPR, huge shadow maps, or too many lights on mobile.

  • Letting the object compete with foreground copy or CTAs.

Quick Checks

  • The object has visible form, edges, highlights, and shadows.

  • The material uses metalness, roughness, and optional emissive.

  • Directional and ambient lights are both present.

  • The camera is perspective, not orthographic by accident.

  • Resize does not stretch the object.

  • Geometry, material, event listeners, RAF, and renderer are cleaned up.

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="es" class="scroll-smooth">
<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>PulsoApps | Tu app lista en 5 días.</title>
    
    <!-- Fonts -->
    <style>
        @import url('https://api.fontshare.com/v2/css?f[]=satoshi@700,500,400,300&f[]=erode@400&display=swap');
    </style>

    <!-- Tailwind CSS -->
    <script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
    <script>
        tailwind.config = {
            theme: {
                extend: {
                    colors: {
                        brand: {
                            orange: '#FF4800',
                            black: '#000000',
                            offwhite: '#F5F2EC'
                        }
                    },
                    fontFamily: {
                        sans: ['Satoshi', 'sans-serif'],
                        serif: ['Erode', 'serif'],
                    },
                    boxShadow: {
                        'brutal': '8px 8px 0px 0px rgba(0,0,0,1)',
                        'brutal-sm': '4px 4px 0px 0px rgba(0,0,0,1)',
                        'brutal-hover': '12px 12px 0px 0px rgba(0,0,0,1)',
                    },
                    transitionTimingFunction: {
                        'snap': 'cubic-bezier(0.175, 0.885, 0.32, 1.275)'
                    }
                }
            }
        }
    </script>

    <!-- Scripts -->
    <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>
        body {
            background-color: #F5F2EC;
            color: #000000;
            overflow-x: hidden;
            font-size: 1rem; /* Base fallback */
        }

        /* Utilities */
        .border-brutal { border: 3px solid #000; }
        .border-brutal-b { border-bottom: 3px solid #000; }
        .border-brutal-t { border-top: 3px solid #000; }
        
        .hover-snap {
            transition: all 100ms cubic-bezier(0.175, 0.885, 0.32, 1.275);
        }
        .hover-snap:hover {
            transform: translate(-4px, -4px);
            box-shadow: 12px 12px 0px 0px rgba(0,0,0,1);
        }

        /* Marquee Animation */
        .marquee-container {
            display: flex;
            width: 200%;
            animation: marquee 20s linear infinite;
        }
        @keyframes marquee {
            0% { transform: translateX(0); }
            100% { transform: translateX(-50%); }
        }

        /* Rotating Badge */
        .rotate-slow {
            animation: rotate 12s linear infinite;
        }
        @keyframes rotate {
            100% { transform: rotate(360deg); }
        }

        /* GSAP Mask Reveal Styles */
        .reveal-mask {
            display: inline-block;
            overflow: hidden;
            vertical-align: top;
        }
        .reveal-text {
            display: inline-block;
            transform: translateY(110%);
        }

        /* Border Gradient Wrapper */
        .premium-border-wrap {
            position: relative;
            background: linear-gradient(135deg, #FF4800, #ff8c00, #000000);
            padding: 3px;
            border-radius: 4px;
        }

        /* Custom scrollbar */
        ::-webkit-scrollbar { width: 12px; }
        ::-webkit-scrollbar-track { background: #F5F2EC; border-left: 3px solid #000; }
        ::-webkit-scrollbar-thumb { background: #FF4800; border: 3px solid #000; }

        /* Typography sizing overrides using clamp to avoid px/em but maintain massive scale */
        .text-massive { font-size: clamp(3rem, 10vw, 11rem); line-height: 0.85; }
        .text-huge { font-size: clamp(2.5rem, 8vw, 8rem); line-height: 0.9; }
    </style>
</head>
<body class="font-sans antialiased selection:bg-brand-black selection:text-brand-orange">

    <!-- Navigation -->
    <nav class="fixed top-0 w-full z-50 bg-brand-orange border-brutal-b flex items-center justify-between py-4 px-6 md:px-12">
        <a href="#" class="flex items-center gap-3 hover:opacity-80 transition-opacity">
            <div class="w-10 h-10 bg-white border-[3px] border-black flex items-center justify-center">
                <span class="font-bold text-xl leading-none">P</span>
            </div>
            <span class="font-bold text-2xl tracking-tighter uppercase">PulsoApps</span>
        </a>
        
        <div class="hidden lg:flex items-center gap-8 font-medium text-sm uppercase tracking-wide">
            <a href="#servicios" class="hover:underline decoration-2 underline-offset-4">Servicios</a>
            <a href="#proceso" class="hover:underline decoration-2 underline-offset-4">Proceso</a>
            <a href="#trabajos" class="hover:underline decoration-2 underline-offset-4">Trabajos</a>
            <a href="#precios" class="hover:underline decoration-2 underline-offset-4">Precios</a>
            <a href="#faq" class="hover:underline decoration-2 underline-offset-4">FAQ</a>
        </div>

        <a href="#contacto" class="hidden md:flex bg-brand-black text-white px-6 py-3 font-semibold text-sm uppercase border-brutal shadow-brutal-sm hover-snap items-center gap-2">
            Agenda tu demo <iconify-icon icon="solar:arrow-right-linear" width="20"></iconify-icon>
        </a>
        
        <button class="lg:hidden text-3xl flex items-center justify-center">
            <iconify-icon icon="solar:hamburger-menu-linear"></iconify-icon>
        </button>
    </nav>

    <!-- Hero Section -->
    <section class="relative min-h-screen bg-brand-orange pt-32 pb-20 px-6 md:px-12 flex flex-col justify-center overflow-hidden">
        
        <!-- Background Geometric Elements -->
        <svg class="absolute right-[-10%] top-[10%] w-[60vw] h-[80vh] opacity-20 pointer-events-none z-[2]" viewBox="0 0 100 100" preserveAspectRatio="none">
            <path d="M100 0 L50 50 L100 100" fill="none" stroke="#000" stroke-width="15" />
            <path d="M80 0 L30 50 L80 100" fill="none" stroke="#000" stroke-width="15" />
        </svg>

        <div class="max-w-[1600px] mx-auto w-full grid grid-cols-1 lg:grid-cols-12 gap-12 items-center relative z-10 pointer-events-none">
            
            <!-- Left Copy -->
            <div class="lg:col-span-8 flex flex-col items-start pointer-events-auto">
                <div class="inline-flex items-center gap-2 border-brutal bg-brand-offwhite px-4 py-1.5 font-semibold text-xs tracking-widest uppercase shadow-brutal-sm mb-8">
                    ◆ Estudio de diseño
                </div>
                
                <h1 class="text-massive font-bold tracking-tighter uppercase mb-8" id="hero-title">
                    <span class="reveal-mask"><span class="reveal-text">TU APP LISTA</span></span><br>
                    <span class="reveal-mask"><span class="reveal-text">EN 5 DÍAS.</span></span><br>
                    <span class="reveal-mask"><span class="reveal-text">SIN EXCUSAS.</span></span>
                </h1>
                
                <p class="text-lg md:text-xl font-medium max-w-lg mb-10 leading-relaxed border-l-4 border-black pl-4">
                    Diseñamos y entregamos tu aplicación o sitio web para negocios en una semana hábil. Precio cerrado. Fecha cerrada. Cero vueltas.
                </p>
                
                <div class="flex flex-wrap gap-6 items-center w-full sm:w-auto">
                    <a href="#precios" class="bg-brand-black text-white px-8 py-4 font-semibold text-base uppercase border-brutal shadow-brutal hover-snap flex items-center gap-2 w-full sm:w-auto justify-center">
                        Cotiza en 2 minutos <iconify-icon icon="solar:arrow-right-linear" width="24"></iconify-icon>
                    </a>
                    <a href="#trabajos" class="flex items-center gap-2 font-bold text-base uppercase hover:underline decoration-2 underline-offset-4">
                        Ver trabajos <iconify-icon icon="solar:arrow-right-down-linear" width="24"></iconify-icon>
                    </a>
                </div>
            </div>

            <!-- Empty column to preserve original 8/4 grid layout structure -->
            <div class="hidden lg:block lg:col-span-4"></div>
        </div>

        <!-- Rotating Stamp (Moved to the right to avoid overlapping the left content) -->
        <div class="absolute bottom-12 right-6 md:right-12 w-32 h-32 md:w-40 md:h-40 z-20 hidden md:block">
            <svg viewBox="0 0 100 100" class="w-full h-full rotate-slow overflow-visible">
                <path id="circlePath" d="M 50, 50 m -40, 0 a 40,40 0 1,1 80,0 a 40,40 0 1,1 -80,0" fill="transparent" />
                <text class="text-[10px] font-bold tracking-widest uppercase fill-brand-black">
                    <textPath href="#circlePath" startOffset="0%">
                        ENTREGA GARANTIZADA · 5 DÍAS · ENTREGA GARANTIZADA · 5 DÍAS · 
                    </textPath>
                </text>
            </svg>
            <div class="absolute inset-0 flex items-center justify-center">
                <iconify-icon icon="solar:star-fall-minimalistic-linear" class="text-3xl"></iconify-icon>
            </div>
        </div>
    </section>

    <!-- Trust Bar Marquee -->
    <div class="bg-brand-black text-white py-4 overflow-hidden border-brutal-b flex relative z-20">
        <div class="marquee-container text-sm md:text-base font-semibold tracking-widest uppercase whitespace-nowrap">
            <div class="flex-shrink-0 w-1/2 flex justify-around items-center">
                <span>+40 Proyectos Entregados</span>
                <span>·</span>
                <span>Entrega en 5 días</span>
                <span>·</span>
                <span>Precio Cerrado</span>
                <span>·</span>
                <span>Sin Letra Chica</span>
                <span>·</span>
            </div>
            <div class="flex-shrink-0 w-1/2 flex justify-around items-center">
                <span>+40 Proyectos Entregados</span>
                <span>·</span>
                <span>Entrega en 5 días</span>
                <span>·</span>
                <span>Precio Cerrado</span>
                <span>·</span>
                <span>Sin Letra Chica</span>
                <span>·</span>
            </div>
        </div>
    </div>

    <!-- Servicios Section -->
    <section id="servicios" class="py-24 px-6 md:px-12 bg-brand-offwhite relative z-20">
        <div class="max-w-[1600px] mx-auto">
            <div class="flex flex-col md:flex-row justify-between items-end mb-16 gap-8">
                <h2 class="text-huge font-bold tracking-tighter uppercase section-title">
                    Lo que <br> hacemos.
                </h2>
                <iconify-icon icon="solar:arrow-right-down-linear" class="text-7xl text-brand-orange"></iconify-icon>
            </div>

            <div class="grid grid-cols-1 md:grid-cols-3 gap-8 md:gap-12 relative">
                <!-- Horizontal connecting line for desktop -->
                <div class="hidden md:block absolute top-[40%] left-0 w-full h-[3px] bg-black z-0"></div>

                <!-- Card 1 -->
                <div class="bg-white border-brutal p-8 shadow-brutal flex flex-col relative z-10 md:-translate-y-8 group">
                    <span class="text-6xl font-bold text-brand-orange mb-6 font-serif block">01</span>
                    <h3 class="text-2xl font-bold uppercase tracking-tight mb-4 group-hover:text-brand-orange transition-colors">Aplicaciones de Negocios</h3>
                    <p class="font-medium text-base mb-8 flex-grow">
                        Diseño y desarrollo de tu aplicación web optimizada para automatizar y escalar tu negocio.
                    </p>
                    <ul class="space-y-2 mb-8 font-medium text-sm opacity-80">
                        <li class="flex items-center gap-2"><iconify-icon icon="solar:check-square-linear"></iconify-icon> UI/UX Intuitivo</li>
                        <li class="flex items-center gap-2"><iconify-icon icon="solar:check-square-linear"></iconify-icon> Base de datos</li>
                        <li class="flex items-center gap-2"><iconify-icon icon="solar:check-square-linear"></iconify-icon> Panel de Administración</li>
                    </ul>
                    <a href="#contacto" class="inline-flex items-center gap-2 font-bold uppercase text-sm border-b-2 border-black pb-1 self-start hover:text-brand-orange hover:border-brand-orange transition-colors">
                        Saber más <iconify-icon icon="solar:arrow-right-linear"></iconify-icon>
                    </a>
                </div>

                <!-- Card 2 -->
                <div class="bg-white border-brutal p-8 shadow-brutal flex flex-col relative z-10 md:translate-y-8 group">
                    <span class="text-6xl font-bold text-brand-orange mb-6 font-serif block">02</span>
                    <h3 class="text-2xl font-bold uppercase tracking-tight mb-4 group-hover:text-brand-orange transition-colors">Sitio Web que Vende</h3>
                    <p class="font-medium text-base mb-8 flex-grow">
                        Landing page o sitio completo optimizado para captar clientes. Mobile-first, rápido, con analítica.
                    </p>
                    <ul class="space-y-2 mb-8 font-medium text-sm opacity-80">
                        <li class="flex items-center gap-2"><iconify-icon icon="solar:check-square-linear"></iconify-icon> Carga ultra rápida</li>
                        <li class="flex items-center gap-2"><iconify-icon icon="solar:check-square-linear"></iconify-icon> SEO Técnico</li>
                        <li class="flex items-center gap-2"><iconify-icon icon="solar:check-square-linear"></iconify-icon> Formularios y CMS</li>
                    </ul>
                    <a href="#contacto" class="inline-flex items-center gap-2 font-bold uppercase text-sm border-b-2 border-black pb-1 self-start hover:text-brand-orange hover:border-brand-orange transition-colors">
                        Saber más <iconify-icon icon="solar:arrow-right-linear"></iconify-icon>
                    </a>
                </div>

                <!-- Card 3 -->
                <div class="bg-white border-brutal p-8 shadow-brutal flex flex-col relative z-10 group">
                    <span class="text-6xl font-bold text-brand-orange mb-6 font-serif block">03</span>
                    <h3 class="text-2xl font-bold uppercase tracking-tight mb-4 group-hover:text-brand-orange transition-colors">Rediseño Express</h3>
                    <p class="font-medium text-base mb-8 flex-grow">
                        ¿Ya tienes algo que no funciona? Lo arreglamos y lo modernizamos en 5 días.
                    </p>
                    <ul class="space-y-2 mb-8 font-medium text-sm opacity-80">
                        <li class="flex items-center gap-2"><iconify-icon icon="solar:check-square-linear"></iconify-icon> Auditoría UX</li>
                        <li class="flex items-center gap-2"><iconify-icon icon="solar:check-square-linear"></iconify-icon> Nuevo sistema visual</li>
                        <li class="flex items-center gap-2"><iconify-icon icon="solar:check-square-linear"></iconify-icon> Optimización código</li>
                    </ul>
                    <a href="#contacto" class="inline-flex items-center gap-2 font-bold uppercase text-sm border-b-2 border-black pb-1 self-start hover:text-brand-orange hover:border-brand-orange transition-colors">
                        Saber más <iconify-icon icon="solar:arrow-right-linear"></iconify-icon>
                    </a>
                </div>
            </div>
        </div>
    </section>

    <!-- Proceso Section -->
    <section id="proceso" class="bg-brand-orange py-24 px-6 border-brutal-y relative overflow-hidden z-20">
        <!-- Giant background text -->
        <div class="absolute inset-0 flex items-center justify-center opacity-10 pointer-events-none select-none">
            <span class="text-[30vw] font-bold leading-none uppercase whitespace-nowrap">5 Días</span>
        </div>

        <div class="max-w-[1600px] mx-auto relative z-10">
            <h2 class="text-5xl md:text-7xl font-bold tracking-tighter uppercase mb-16 text-center">
                El Reloj Corre.<br>Nuestro Proceso.
            </h2>

            <div class="relative">
                <!-- Diagonal line connecting steps -->
                <div class="absolute top-1/2 left-0 w-full h-[4px] bg-black -translate-y-1/2 rotate-[-5deg] md:rotate-[-2deg] opacity-20 pointer-events-none"></div>

                <div class="flex flex-col md:flex-row justify-between gap-8 md:gap-4 lg:gap-8">
                    <!-- Step 1 -->
                    <div class="bg-white border-brutal p-6 shadow-brutal-sm w-full md:w-1/5 md:translate-y-12 rotate-1 hover:rotate-0 transition-transform">
                        <div class="font-bold text-xl mb-2 uppercase border-b-2 border-black pb-2">01. Lunes</div>
                        <p class="font-medium text-sm">Briefing y alcance cerrado.</p>
                    </div>
                    <!-- Step 2 -->
                    <div class="bg-brand-black text-white border-brutal p-6 shadow-brutal-sm w-full md:w-1/5 md:translate-y-4 -rotate-1 hover:rotate-0 transition-transform">
                        <div class="font-bold text-xl mb-2 uppercase border-b-2 border-white pb-2 text-brand-orange">02. Martes</div>
                        <p class="font-medium text-sm">Diseño UI aprobado por ti.</p>
                    </div>
                    <!-- Step 3 -->
                    <div class="bg-white border-brutal p-6 shadow-brutal-sm w-full md:w-1/5 md:-translate-y-4 rotate-2 hover:rotate-0 transition-transform">
                        <div class="font-bold text-xl mb-2 uppercase border-b-2 border-black pb-2">03. Miércoles</div>
                        <p class="font-medium text-sm">Desarrollo del core.</p>
                    </div>
                    <!-- Step 4 -->
                    <div class="bg-white border-brutal p-6 shadow-brutal-sm w-full md:w-1/5 md:-translate-y-12 -rotate-2 hover:rotate-0 transition-transform">
                        <div class="font-bold text-xl mb-2 uppercase border-b-2 border-black pb-2">04. Jueves</div>
                        <p class="font-medium text-sm">Integraciones y testing QA.</p>
                    </div>
                    <!-- Step 5 -->
                    <div class="bg-white border-brutal p-6 shadow-brutal-sm w-full md:w-1/5 md:-translate-y-20 rotate-1 hover:rotate-0 transition-transform">
                        <div class="font-bold text-xl mb-2 uppercase border-b-2 border-black pb-2 text-brand-orange">05. Viernes</div>
                        <p class="font-medium text-sm">Entrega y publicación.</p>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Trabajos Section -->
    <section id="trabajos" class="py-24 px-6 md:px-12 bg-brand-black text-white z-20 relative">
        <div class="max-w-[1600px] mx-auto">
            <div class="flex flex-col md:flex-row justify-between items-start mb-16 gap-8">
                <h2 class="text-huge font-bold tracking-tighter uppercase section-title text-brand-offwhite">
                    Trabajos <br> Recientes.
                </h2>
                <p class="text-lg max-w-sm font-medium text-gray-300 border-l-2 border-brand-orange pl-4">
                    Construimos productos reales para negocios reales que querían ir rápido.
                </p>
            </div>

            <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-8">
                <!-- Project 1 -->
                <a href="#" class="block group">
                    <div class="relative aspect-[4/3] border-brutal border-white overflow-hidden mb-4">
                        <img src="assets/page-01-4734259a-bad7-422f-981e-ce01e79184f2-1600w.jpg" alt="Proyecto App" class="object-cover w-full h-full grayscale group-hover:grayscale-0 group-hover:scale-105 transition-all duration-500">
                        <div class="absolute top-4 left-4 bg-white text-black font-bold text-xs px-3 py-1 uppercase border-brutal">App Web</div>
                    </div>
                    <div class="flex justify-between items-center">
                        <h3 class="text-xl font-bold uppercase">Fintech Neo</h3>
                        <iconify-icon icon="solar:arrow-right-up-linear" class="text-2xl group-hover:text-brand-orange transition-colors"></iconify-icon>
                    </div>
                </a>

                <!-- Project 2 -->
                <a href="#" class="block group lg:-translate-y-12">
                    <div class="relative aspect-[4/3] border-brutal border-white overflow-hidden mb-4">
                        <img src="assets/page-02-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg" alt="Proyecto Web" class="object-cover w-full h-full grayscale group-hover:grayscale-0 group-hover:scale-105 transition-all duration-500">
                        <div class="absolute top-4 left-4 bg-white text-black font-bold text-xs px-3 py-1 uppercase border-brutal">Web</div>
                    </div>
                    <div class="flex justify-between items-center">
                        <h3 class="text-xl font-bold uppercase">Estudio Ark</h3>
                        <iconify-icon icon="solar:arrow-right-up-linear" class="text-2xl group-hover:text-brand-orange transition-colors"></iconify-icon>
                    </div>
                </a>

                <!-- Project 3 -->
                <a href="#" class="block group">
                    <div class="relative aspect-[4/3] border-brutal border-white overflow-hidden mb-4">
                        <img src="assets/page-03-fa51902b-c2a4-4c33-a96e-a8f1ef67edc6-1600w.jpg" alt="Proyecto Rediseño" class="object-cover w-full h-full grayscale group-hover:grayscale-0 group-hover:scale-105 transition-all duration-500">
                        <div class="absolute top-4 left-4 bg-white text-black font-bold text-xs px-3 py-1 uppercase border-brutal">Rediseño</div>
                    </div>
                    <div class="flex justify-between items-center">
                        <h3 class="text-xl font-bold uppercase">Club Nocturno</h3>
                        <iconify-icon icon="solar:arrow-right-up-linear" class="text-2xl group-hover:text-brand-orange transition-colors"></iconify-icon>
                    </div>
                </a>

                 <!-- Project 4 -->
                 <a href="#" class="block group lg:translate-y-12 hidden md:block">
                    <div class="relative aspect-[4/3] border-brutal border-white overflow-hidden mb-4">
                        <img src="assets/page-04-005600e5-f6ab-4e59-bc86-eaeb02797dfa-1600w.jpg" alt="Proyecto Web" class="object-cover w-full h-full grayscale group-hover:grayscale-0 group-hover:scale-105 transition-all duration-500">
                        <div class="absolute top-4 left-4 bg-white text-black font-bold text-xs px-3 py-1 uppercase border-brutal">Web</div>
                    </div>
                    <div class="flex justify-between items-center">
                        <h3 class="text-xl font-bold uppercase">Villa Real Estate</h3>
                        <iconify-icon icon="solar:arrow-right-up-linear" class="text-2xl group-hover:text-brand-orange transition-colors"></iconify-icon>
                    </div>
                </a>
            </div>
            
            <div class="mt-20 text-center lg:mt-32">
                <a href="#" class="inline-flex bg-white text-black px-8 py-4 font-semibold text-base uppercase border-brutal shadow-[6px_6px_0px_#FF4800] hover:translate-x-[-2px] hover:translate-y-[-2px] hover:shadow-[8px_8px_0px_#FF4800] transition-all items-center gap-2">
                    Ver todos los casos <iconify-icon icon="solar:widget-add-linear" width="24"></iconify-icon>
                </a>
            </div>
        </div>
    </section>

    <!-- Precios Section -->
    <section id="precios" class="py-24 px-6 md:px-12 bg-brand-offwhite z-20 relative">
        <div class="max-w-[1400px] mx-auto">
            <div class="text-center mb-16">
                <h2 class="text-5xl md:text-7xl font-bold tracking-tighter uppercase mb-6">Precios Claros.</h2>
                <p class="text-xl font-medium max-w-xl mx-auto">Sin estimaciones por hora. Sabes lo que pagas y cuándo lo recibes desde el día cero.</p>
            </div>

            <div class="grid grid-cols-1 md:grid-cols-3 gap-8 items-center">
                <!-- Plan Starter -->
                <div class="bg-white border-brutal p-8 flex flex-col h-[90%]">
                    <h3 class="text-2xl font-bold uppercase mb-2">Starter</h3>
                    <div class="text-3xl md:text-4xl font-black mb-6 border-b-2 border-black pb-6">150$ <span class="text-xl text-gray-500 font-bold">A BCV</span></div>
                    <ul class="space-y-4 mb-8 flex-grow font-medium">
                        <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 shrink-0"></iconify-icon> Landing page 1 página</li>
                        <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 shrink-0"></iconify-icon> Entrega en 5 días</li>
                        <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 shrink-0"></iconify-icon> Diseño Responsivo</li>
                        <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 shrink-0"></iconify-icon> Formulario de contacto</li>
                    </ul>
                    <a href="#contacto" class="block text-center w-full bg-brand-offwhite text-black border-brutal py-3 font-bold uppercase text-sm hover:bg-black hover:text-white transition-colors">
                        Elegir plan
                    </a>
                </div>

                <!-- Plan Pulso -->
                <div class="premium-border-wrap shadow-brutal z-10 md:-mx-4 h-full relative">
                    <div class="absolute -top-4 left-1/2 -translate-x-1/2 bg-black text-brand-orange font-bold text-xs px-4 py-1 uppercase tracking-widest border-brutal border-white z-20 whitespace-nowrap">
                        Más Elegido
                    </div>
                    <div class="bg-white p-8 border-[1px] border-transparent h-full flex flex-col">
                        <h3 class="text-3xl font-bold uppercase mb-2 text-brand-orange">Pulso</h3>
                        <div class="text-4xl md:text-5xl font-black mb-6 border-b-2 border-black pb-6">250$ <span class="text-2xl text-gray-500 font-bold">A BCV</span></div>
                        <ul class="space-y-4 mb-8 flex-grow font-medium">
                            <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 text-brand-orange shrink-0"></iconify-icon> Aplicación web o sitio (hasta 5 views)</li>
                            <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 text-brand-orange shrink-0"></iconify-icon> Entrega en 5 días Hábiles</li>
                            <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 text-brand-orange shrink-0"></iconify-icon> CMS o Base de datos básica</li>
                            <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 text-brand-orange shrink-0"></iconify-icon> Integración pasarela de pagos</li>
                            <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 text-brand-orange shrink-0"></iconify-icon> 30 días de soporte post-lanzamiento</li>
                        </ul>
                        <a href="#contacto" class="block text-center w-full bg-brand-orange text-black border-brutal py-4 font-bold uppercase text-base hover-snap shadow-brutal-sm">
                            Elegir plan
                        </a>
                    </div>
                </div>

                <!-- Plan Pro -->
                <div class="bg-brand-black text-white border-brutal p-8 flex flex-col h-[90%]">
                    <h3 class="text-2xl font-bold uppercase mb-2 text-gray-300">Pro</h3>
                    <div class="text-3xl md:text-4xl font-black mb-6 border-b-2 border-white pb-6">300$ <span class="text-xl text-gray-400 font-bold">A BCV</span></div>
                    <ul class="space-y-4 mb-8 flex-grow font-medium text-gray-300">
                        <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 shrink-0"></iconify-icon> Aplicación + Sitio Web conectadas</li>
                        <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 shrink-0"></iconify-icon> Entrega en 10 días</li>
                        <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 shrink-0"></iconify-icon> Panel de admin avanzado</li>
                        <li class="flex gap-3"><iconify-icon icon="solar:check-circle-linear" class="text-xl mt-0.5 shrink-0"></iconify-icon> Integraciones de terceros complejas</li>
                    </ul>
                    <a href="#contacto" class="block text-center w-full bg-transparent text-white border-brutal border-white py-3 font-bold uppercase text-sm hover:bg-white hover:text-black transition-colors">
                        Elegir plan
                    </a>
                </div>
            </div>
        </div>
    </section>

    <!-- FAQ Section -->
    <section id="faq" class="py-24 px-6 md:px-12 bg-brand-offwhite z-20 relative">
        <div class="max-w-[800px] mx-auto">
            <h2 class="text-5xl md:text-7xl font-bold tracking-tighter uppercase mb-16 text-center">
                Preguntas.<br>Respuestas.
            </h2>

            <div class="space-y-4">
                <!-- FAQ Item 1 -->
                <details class="group bg-white border-brutal shadow-brutal-sm [&_summary::-webkit-details-marker]:hidden">
                    <summary class="flex cursor-pointer items-center justify-between p-6 font-bold text-lg md:text-xl uppercase">
                        ¿Qué pasa si no entregan en 5 días?
                        <span class="transition duration-300 group-open:-rotate-180">
                            <iconify-icon icon="solar:alt-arrow-down-linear" class="text-2xl"></iconify-icon>
                        </span>
                    </summary>
                    <div class="border-t-[3px] border-black p-6 font-medium text-base bg-brand-offwhite">
                        Te devolvemos el 50% de tu dinero. Así de seguros estamos de nuestro proceso. No prometemos lo que no podemos cumplir.
                    </div>
                </details>

                <!-- FAQ Item 2 -->
                <details class="group bg-white border-brutal shadow-brutal-sm [&_summary::-webkit-details-marker]:hidden">
                    <summary class="flex cursor-pointer items-center justify-between p-6 font-bold text-lg md:text-xl uppercase">
                        ¿Y si necesito cambios después?
                        <span class="transition duration-300 group-open:-rotate-180">
                            <iconify-icon icon="solar:alt-arrow-down-linear" class="text-2xl"></iconify-icon>
                        </span>
                    </summary>
                    <div class="border-t-[3px] border-black p-6 font-medium text-base bg-brand-offwhite">
                        El plan Pulso incluye 30 días de soporte para bugs. Si necesitas features nuevas, ofrecemos paquetes de mantenimiento mensual a precio cerrado.
                    </div>
                </details>

                <!-- FAQ Item 3 -->
                <details class="group bg-white border-brutal shadow-brutal-sm [&_summary::-webkit-details-marker]:hidden">
                    <summary class="flex cursor-pointer items-center justify-between p-6 font-bold text-lg md:text-xl uppercase">
                        ¿Cómo cobran?
                        <span class="transition duration-300 group-open:-rotate-180">
                            <iconify-icon icon="solar:alt-arrow-down-linear" class="text-2xl"></iconify-icon>
                        </span>
                    </summary>
                    <div class="border-t-[3px] border-black p-6 font-medium text-base bg-brand-offwhite">
                        50% por adelantado para bloquear la semana de desarrollo, 50% contra entrega del proyecto funcionando.
                    </div>
                </details>
                
                 <!-- FAQ Item 4 -->
                 <details class="group bg-white border-brutal shadow-brutal-sm [&_summary::-webkit-details-marker]:hidden">
                    <summary class="flex cursor-pointer items-center justify-between p-6 font-bold text-lg md:text-xl uppercase">
                        ¿Qué necesitan de mí para arrancar?
                        <span class="transition duration-300 group-open:-rotate-180">
                            <iconify-icon icon="solar:alt-arrow-down-linear" class="text-2xl"></iconify-icon>
                        </span>
                    </summary>
                    <div class="border-t-[3px] border-black p-6 font-medium text-base bg-brand-offwhite">
                        Llenar un formulario detallado con tu idea, logos, colores de marca y el contenido (textos) básico. Nosotros ponemos el resto.
                    </div>
                </details>
            </div>
        </div>
    </section>

    <!-- Final CTA Section -->
    <section class="bg-brand-black text-white py-32 px-6 md:px-12 flex flex-col items-center justify-center text-center relative border-brutal-y z-20">
        <div class="absolute inset-0 bg-[url('assets/page-05-5ee0a38a-b5d3-4531-8793-98beed4af162-1600w.jpg')] bg-cover bg-center opacity-20 mix-blend-luminosity"></div>
        
        <div class="relative z-10 max-w-4xl">
            <h2 class="text-huge font-bold tracking-tighter uppercase mb-8 leading-[0.85]">
                DEJA DE <br> POSTERGAR <br> TU PROYECTO. <span class="text-brand-orange">→</span>
            </h2>
            <p class="text-xl md:text-2xl font-medium max-w-2xl mx-auto mb-12 text-gray-300">
                Agenda una llamada de 15 minutos. Te decimos si podemos entregarte en 5 días — o te mandamos a otro lado.
            </p>
            <a href="#contacto" class="inline-flex bg-brand-orange text-black px-10 py-5 font-bold text-xl md:text-2xl uppercase border-brutal border-white shadow-[8px_8px_0px_#fff] hover-snap items-center gap-3">
                Agenda tu demo gratis <iconify-icon icon="solar:calendar-add-linear"></iconify-icon>
            </a>
        </div>
    </section>

    <!-- Footer -->
    <footer class="bg-brand-black text-white py-12 px-6 md:px-12 border-t-4 border-brand-orange z-20 relative">
        <div class="max-w-[1600px] mx-auto grid grid-cols-1 md:grid-cols-4 gap-12 items-start">
            
            <div class="md:col-span-1">
                <a href="#" class="flex items-center gap-3 mb-6">
                    <div class="w-10 h-10 bg-white border-[3px] border-white flex items-center justify-center">
                        <span class="font-bold text-xl text-black leading-none">P</span>
                    </div>
                    <span class="font-bold text-2xl tracking-tighter uppercase">PulsoApps</span>
                </a>
                <p class="font-medium text-sm text-gray-400 max-w-xs">
                    El estudio que convierte ideas en código funcional en una semana hábil.
                </p>
            </div>

            <div class="md:col-span-1 flex flex-col gap-3 font-semibold text-sm uppercase">
                <a href="#servicios" class="hover:text-brand-orange transition-colors">Servicios</a>
                <a href="#proceso" class="hover:text-brand-orange transition-colors">Proceso</a>
                <a href="#trabajos" class="hover:text-brand-orange transition-colors">Trabajos</a>
                <a href="#precios" class="hover:text-brand-orange transition-colors">Precios</a>
                <a href="#faq" class="hover:text-brand-orange transition-colors">FAQ</a>
            </div>

            <div class="md:col-span-1 flex flex-col gap-3 font-semibold text-sm uppercase">
                <a href="https://instagram.com/pulso.apps" target="_blank" class="flex items-center gap-2 hover:text-brand-orange transition-colors">
                    <iconify-icon icon="solar:smartphone-2-linear" class="text-xl"></iconify-icon> @pulso.apps
                </a>
                <a href="mailto:pulsoapps@outlook.com" class="flex items-center gap-2 hover:text-brand-orange transition-colors">
                    <iconify-icon icon="solar:letter-linear" class="text-xl"></iconify-icon> pulsoapps@outlook.com
                </a>
            </div>

            <div class="md:col-span-1 flex justify-start md:justify-end">
                <div class="w-24 h-24 bg-brand-orange border-brutal border-white flex flex-col items-center justify-center p-2 text-center rotate-3">
                    <span class="font-bold text-black uppercase leading-none text-xs">Hecho en</span>
                    <span class="font-black text-black text-3xl leading-none font-serif mt-1">5</span>
                    <span class="font-bold text-black uppercase leading-none text-xs">Días</span>
                </div>
            </div>
        </div>
        
        <div class="max-w-[1600px] mx-auto mt-12 pt-6 border-t border-gray-800 flex flex-col md:flex-row justify-between items-center text-xs font-medium text-gray-500 uppercase tracking-widest">
            <p>© 2026 PulsoApps. Hecho en 5 días, obvio.</p>
            <p class="mt-2 md:mt-0">Diseñado sin excusas.</p>
        </div>
    </footer>

    <!-- Floating WhatsApp Button -->
    <a href="https://wa.me/584247450708" target="_blank" class="fixed bottom-6 right-6 z-50 bg-[#25D366] text-white border-brutal shadow-brutal hover-snap flex items-center justify-center w-14 h-14 md:w-auto md:h-auto md:px-5 md:py-3 gap-2">
        <iconify-icon icon="mdi:whatsapp" class="text-4xl md:text-3xl"></iconify-icon>
        <span class="hidden md:block font-bold uppercase text-sm tracking-wide">Chatear</span>
    </a>

    <!-- GSAP Initialization -->
    <script>
        document.addEventListener("DOMContentLoaded", (event) => {
            gsap.registerPlugin(ScrollTrigger);

            // 1. GSAP Masked Reveal for Hero Headline
            const heroTexts = document.querySelectorAll('#hero-title .reveal-text');
            gsap.to(heroTexts, {
                y: "0%",
                duration: 1.2,
                stagger: 0.15,
                ease: "power4.out",
                delay: 0.2
            });

            // Reveal animations for section titles on scroll
            const sectionTitles = document.querySelectorAll('.section-title');
            sectionTitles.forEach(title => {
                gsap.from(title, {
                    scrollTrigger: {
                        trigger: title,
                        start: "top 85%",
                    },
                    y: 50,
                    opacity: 0,
                    duration: 0.8,
                    ease: "power3.out"
                });
            });
        });
    </script>
</body>
</html>
";
    const assetFiles = ["assets/page-01-4734259a-bad7-422f-981e-ce01e79184f2-1600w.jpg","assets/page-02-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg","assets/page-03-fa51902b-c2a4-4c33-a96e-a8f1ef67edc6-1600w.jpg","assets/page-04-005600e5-f6ab-4e59-bc86-eaeb02797dfa-1600w.jpg","assets/page-05-5ee0a38a-b5d3-4531-8793-98beed4af162-1600w.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/webgl-3d-object · 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 webgl-3d-object.zip