<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by daisy 🌼 on Medium]]></title>
        <description><![CDATA[Stories by daisy 🌼 on Medium]]></description>
        <link>https://medium.com/@daisythoughts?source=rss-64894e44bf71------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*w_uMmlmXrALLs4-PBzgI_g.jpeg</url>
            <title>Stories by daisy 🌼 on Medium</title>
            <link>https://medium.com/@daisythoughts?source=rss-64894e44bf71------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 23:15:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@daisythoughts/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Intern Blog Series: How I Built an Infinite Parallax Grid with GSAP (from a Beginner’s Perspective)]]></title>
            <link>https://blog.zero-one-group.com/intern-blog-series-how-i-built-an-infinite-parallax-grid-with-gsap-from-a-beginners-perspective-ca11deb1239b?source=rss-64894e44bf71------2</link>
            <guid isPermaLink="false">https://medium.com/p/ca11deb1239b</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[intern]]></category>
            <category><![CDATA[animation]]></category>
            <category><![CDATA[gsap]]></category>
            <dc:creator><![CDATA[daisy ]]></dc:creator>
            <pubDate>Wed, 08 Oct 2025 02:47:44 GMT</pubDate>
            <atom:updated>2025-10-08T02:47:44.018Z</atom:updated>
            <content:encoded><![CDATA[<h3>Who Am I</h3><p>My name is Nadia Lovely. A second year of computer science at Institut Teknologi Sepuluh Nopember. It&#39;s also my third year to dive and explore in the technology field, and my third year to fall in love with frontend engineer. After finishing several committees I did in college, I still have a big appetite to try another experience, and here I am, an intern as a product engineer while doing my college. I have never touched any GSAP or Three.js js but Mas Doni gave me a chance to learn it.</p><h3>What We Will Cover</h3><p>I promised a bite-sized, hands-on session, so here’s the plan. Over the next 15 minutes, you’ll learn how to build a parallax infinity effect in the most beginner-friendly way possible. I’ll walk you through the process step by step, complete with visuals, so even if you’re new to GSAP, you can follow along easily.</p><p>We’ve already covered the intro. This was it! Next, we’ll look at what kind of case study I bring here. Next, before diving into the code, we will try to understand how it works and the concept of parallax infinity first. Finally, we go to the code itself, what kind of error I discovered, and another approach I tried. At the end, we’ll wrap it up with what I learned (and maybe what you can take from it too). Let’s give it a go!</p><h3><strong>Project Overview</strong></h3><p>I’ve created a full version of the project, which you can check out here: <a href="https://parallax-infinity-eqmu.vercel.app/">https://parallax-infinity-eqmu.vercel.app/</a>. In this article, we’ll focus on the <strong>last section of the website</strong>, the <strong>parallax infinity</strong> effect. A quick disclaimer that this section is inspired by the tutorial <a href="https://tympanus.net/codrops/2025/06/11/building-an-infinite-parallax-grid-with-gsap-and-seamless-tiling/"><em>Building an Infinite Parallax Grid with GSAP and Seamless Tiling</em></a><em> </em>by the amazing <strong>Jorge Toloza</strong>.</p><p>However, the original tutorial can be a bit overwhelming for beginners. It includes some intermediate-level math, a few implicit assumptions (like how offsets are combined and how the tiling logic works), and the code can feel dense at first, with multiple nested loops and overlapping variables such as extraX and extraY.</p><p>In this post, I’ll break it down in a simpler and more beginner-friendly way.</p><h3>Concept</h3><p>Before we dive into the code, let’s take a moment to understand how this section actually works.</p><p>As the name suggests, Parallax Infinity combines two ideas: Parallax and Infinity.<br>In web design, the parallax effect is when objects appear to move at different speeds depending on the viewer’s scroll or perspective, creating a sense of depth and motion.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*wQzH9jOkKQKZ8G-3gihv2A.gif" /><figcaption>Source: <a href="https://id.pinterest.com/pin/6966574415331788/">https://id.pinterest.com/pin/6966574415331788/</a></figcaption></figure><p>While <em>infinity</em> refers to a state where a section has no end, no matter how many times you scroll to the right, left, top, or bottom, you’ll never reach the edge. Now, what about the <em>grid</em> itself? In this case study, a grid is a base collage of image tiles arranged using exact <strong>x</strong>, <strong>y</strong>, <strong>width</strong>, and <strong>height</strong> values (note that when I say “grid” here, I don’t mean a CSS Grid).</p><p>For an overview, here’s a visualization in Figma showing how it works. First, we determine each image’s position using Figma, and in this visualization, I’ve included the <strong>x</strong>, <strong>y</strong>, <strong>width</strong>, and <strong>height</strong> of every image.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UiWj-ZJ9ClZVIpFGPladVw.png" /></figure><p>Here’s what I mean by the grid. Each grid contains the same image positions and sizes. Every tile is arranged with identical x, y, width, and height values.</p><p>In other words, each frame is a duplicate of the same layout. When we later apply the parallax infinity effect, these grids will seamlessly loop as you scroll in any direction, making it look like the images go on forever.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u1CoRL1oec4Ou-4LddVEzQ.png" /></figure><p>You might be wondering why we set up a 2×2 grid and how the infinity effect actually works. In simple terms, whenever the viewport moves from one grid section to another, any grid that leaves the screen is repositioned to fill the space on the opposite side.</p><p>When moving horizontally, the column that exits the screen on the left reappears on the far right (with the same top and bottom pairing), and vice versa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*YfXIvxz0C9XOsghi10YVMw.gif" /></figure><p>When moving vertically, the wrap happens along the Y-axis, where rows are recycled from top to bottom or bottom to top while their left-to-right order remains the same.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*ZA61baf2RbRvE_OlApurQw.gif" /></figure><p>When moving diagonally and touching both edges at once, the grid wraps in both directions at the same time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*LL17lbXUVTHskq9uIGxqfQ.gif" /></figure><p>Note: In the visualization, you’ll see the X-axis and Y-axis movements shown one after another. That’s only because it’s difficult to record both directions at the same time. In reality, when the user moves diagonally, both X and Y repositioning happen together within a single frame.</p><p>Now that we’ve covered the concept, let’s move on to the code!</p><h3>Implementation</h3><p>What we’re going to do is define a data structure for each item inside the grid parallax.el, container, wrapper, and img are used as reference DOM elements.x, y, w, and h Describe the position and size of each item.extraX and They extraY are used to add offsets for the infinite scroll effect.rect is used for position calculation, while ease controlling the easing animation, which varies for each item.</p><pre>interface GridItem {<br>  el: HTMLDivElement;<br>  container: HTMLDivElement;<br>  wrapper: HTMLDivElement;<br>  img: HTMLImageElement;<br>  x: number;<br>  y: number;<br>  w: number;<br>  h: number;<br>  extraX: number;<br>  extraY: number;<br>  rect: DOMRect;<br>  ease: number;<br>}</pre><p>Now, let’s move into the code inside the ParallaxGrid() function. The main purpose of this code is to manage the states and references needed for animation and interaction</p><ul><li>containerRef is used as a reference to the main container.</li><li>scrollRef manages the scroll position with easing, including the current position, target position, last position (previous frame), and delta (the difference between positions used for animation calculations).</li><li>mouseRef, as the name suggests, tracks the mouse position and state (whether it’s pressed or not).</li><li>The other refs are used for the observer, animation control, drag interactions, and size tracking.</li></ul><pre> const containerRef = useRef&lt;HTMLDivElement&gt;(null);<br>  const scrollRef = useRef({<br>    ease: 0.06,<br>    current: { x: 0, y: 0 },<br>    target: { x: 0, y: 0 },<br>    last: { x: 0, y: 0 },<br>    delta: { x: { c: 0, t: 0 }, y: { c: 0, t: 0 } },<br>  });<br>  const mouseRef = useRef({<br>    x: { t: 0.5, c: 0.5 },<br>    y: { t: 0.5, c: 0.5 },<br>    press: { t: 0, c: 0 },<br>  });<br>  const itemsRef = useRef&lt;GridItem[]&gt;([]);<br>  const observerRef = useRef&lt;IntersectionObserver | null&gt;(null);<br>  const animationRef = useRef&lt;number | null&gt;(null);<br>  const isDraggingRef = useRef(false);<br>  const dragRef = useRef({ startX: 0, startY: 0, scrollX: 0, scrollY: 0 });<br>  const tileSizeRef = useRef({ w: 0, h: 0 });<br>  const winSizeRef = useRef({ w: 0, h: 0 });</pre><p>The code below shows how we define the data configuration. You can customize how much data you want to display and adjust its position as well. The positions are taken from the Figma layout I mentioned earlier.originalSize represents the original grid size, which will later be used for scaling.</p><pre>const sources = useMemo(<br>    () =&gt; [<br>      {<br>        src: &quot;/work/desktop/aurora-desktop.webp&quot;,<br>        caption:<br>          &quot;Aurora &lt;br&gt;Creative Design Project &lt;br&gt;Modern Interface Design &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/elysian-desktop.webp&quot;,<br>        caption:<br>          &quot;Elysian &lt;br&gt;Brand Experience &lt;br&gt;Visual Identity System &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/lume-desktop.webp&quot;,<br>        caption:<br>          &quot;Lume &lt;br&gt;Digital Experience &lt;br&gt;User Interface Design &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/noir-desktop.webp&quot;,<br>        caption: &quot;Noir &lt;br&gt;Creative Process &lt;br&gt;Dark Theme Interface &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/serenity-desktop.webp&quot;,<br>        caption:<br>          &quot;Serenity &lt;br&gt;Minimal Design &lt;br&gt;Clean User Experience &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/aurora-desktop.webp&quot;,<br>        caption: &quot;Hero Image &lt;br&gt;Main Visual &lt;br&gt;Creative Direction &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/elysian-desktop.webp&quot;,<br>        caption:<br>          &quot;Introduction &lt;br&gt;About Our Studio &lt;br&gt;Creative Vision &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/lume-desktop.webp&quot;,<br>        caption:<br>          &quot;Studio Space &lt;br&gt;Creative Environment &lt;br&gt;Workspace Design &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/serenity-desktop.webp&quot;,<br>        caption:<br>          &quot;Studio View &lt;br&gt;Team Collaboration &lt;br&gt;Creative Process &lt;br&gt;2024&quot;,<br>      },<br>    ],<br>    []<br>  );<br><br>  const data = useMemo(<br>    () =&gt; [<br>      { x: 71, y: 58, w: 400, h: 270 },<br>      { x: 211, y: 255, w: 540, h: 360 },<br>      { x: 631, y: 158, w: 400, h: 270 },<br>      { x: 1191, y: 245, w: 260, h: 195 },<br>      { x: 351, y: 687, w: 260, h: 290 },<br>      { x: 751, y: 824, w: 205, h: 154 },<br>      { x: 911, y: 540, w: 260, h: 350 },<br>      { x: 1051, y: 803, w: 400, h: 300 },<br>      { x: 71, y: 922, w: 350, h: 260 },<br>    ],<br>    []<br>  );<br><br>  const originalSize = useMemo(() =&gt; ({ w: 1522, h: 1238 }), []);</pre><p>After defining the data we want to display, let’s create an initial animation that runs when the user visits this section for the first time.</p><p>We’ll start by finding which items are currently visible on the screen. The variable introItems searches for all .item-wrapper elements and filters them to check which ones are inside the <strong>viewport</strong>.</p><p>Next, for each visible item, we’ll center it on the screen using a simple forEach loop. This helps us create a nice “entry” effect before everything animates into place.</p><p>Finally, we’ll use <strong>GSAP</strong> to move each centered item back to its original position with a <strong>staggered animation</strong>, meaning each item moves one after another.</p><pre>const initIntro = useCallback(() =&gt; {<br>    if (!containerRef.current) return;<br><br>    const introItems = Array.from(<br>      containerRef.current.querySelectorAll(&quot;.item-wrapper&quot;)<br>    ).filter((item) =&gt; {<br>      const rect = item.getBoundingClientRect();<br>      return (<br>        rect.x &gt; -rect.width &amp;&amp;<br>        rect.x &lt; window.innerWidth + rect.width &amp;&amp;<br>        rect.y &gt; -rect.height &amp;&amp;<br>        rect.y &lt; window.innerHeight + rect.height<br>      );<br>    });<br><br>    introItems.forEach((item) =&gt; {<br>      const rect = item.getBoundingClientRect();<br>      const x = -rect.x + window.innerWidth * 0.5 - rect.width * 0.5;<br>      const y = -rect.y + window.innerHeight * 0.5 - rect.height * 0.5;<br>      gsap.set(item, { x, y });<br>    });<br><br>    gsap.to(introItems.reverse(), {<br>      duration: 2,<br>      ease: &quot;expo.inOut&quot;,<br>      x: 0,<br>      y: 0,<br>      stagger: 0.05,<br>    });<br>  }, []);</pre><p>Code above will create this initial animation</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*4772d8lGIVKetAke_Gi_PQ.gif" /></figure><h4>Resize Handler</h4><p>The next part of our code will be a bit long. This section is the <strong>core</strong> of how our infinite grid works, so it’s important to understand what’s going on here.</p><h4>1. Setting up the basic viewport values</h4><p>First, we calculate the <strong>tile size</strong> based on the current viewport dimensions.<br>This ensures that our layout stays responsive. For example, if the browser window changes size, the grid will automatically adapt to the new width and height.</p><p>We also reset the <strong>scroll state</strong> and clear the container (containerRef.current.innerHTML = &quot;&quot;). This step helps us start fresh every time the page is resized, so we don’t accidentally stack old elements on top of each other.</p><h4>2. Scaling items based on viewport size</h4><p>Next, we create baseItems, which scales the position and size of each image to fit the current screen size.</p><p>Each object in the data array contains the original coordinates (x, y, w, and h) of every image, taken from the Figma design. We then calculate scaleX and scaleY by comparing the <strong>current tile size</strong> to the <strong>original size</strong> (1522x1238).</p><p>By multiplying x, y, w, and h With these scale values, we make sure that the layout keeps its proportions no matter what device the user is on —<br> whether it’s a desktop (1920x1080), a laptop (1366x768), or even a mobile screen (375x667).</p><h4>3. Creating the infinite 2x2 tiling</h4><p>Now we move on to the fun part, building the <strong>infinite loop effec</strong>t! We use two arrays, repsX and repsY, to define the offsets for the X and Y axes.<br>Each of these arrays contains two values: [0, tileSize].</p><p>When we loop through both repsX and repsYWe end up creating <strong>four copies</strong> of each item, forming a 2x2 grid.<br> This is what allows the parallax grid to appear endless. As one section moves out of view, another identical section takes its place.</p><h4>4. Building each item’s DOM structure</h4><p>Inside the triple-nested forEachWe dynamically create the HTML elements for each image:</p><ul><li>A parent .item container</li><li>A .item-wrapper element to handle animations</li><li>A .item-image div that holds the actual img</li><li>A caption element that contains the project title or description</li></ul><p>We then append all of these elements to the main container. If we have an observerRefWe also use it to <strong>observe</strong> the captions, which allows us to trigger animations when the text enters or leaves the viewport.</p><p>Each completed item is saved toitemsRefwhich keeps track of every item’s element, position, and animation settings. We also assign a random ease value to each item so their animations feel more natural and less robotic.</p><h4>5. Expanding the grid and setting initial scroll values</h4><p>After generating all items, we double the tileSize (both width and height) because our effective grid area now covers <strong>two tiles in each direction</strong>.</p><p>Finally, we use <strong>chained assignments</strong> to set the current, target, and last scroll positions to small negative values. We do this because the grid starts slightly <strong>outside</strong> the visible screen, providing users with space to scroll in all directions: left, right, up, and down.</p><p>This setup creates the foundation of the infinity effect. When we start animating later, these tiles will continuously wrap around, creating the illusion that the grid has no boundaries.</p><pre>  const onResize = useCallback(() =&gt; {<br>    winSizeRef.current.w = window.innerWidth;<br>    winSizeRef.current.h = window.innerHeight;<br><br>    tileSizeRef.current = {            <br>      w: winSizeRef.current.w,<br>      h: winSizeRef.current.w * (originalSize.h / originalSize.w),<br>    };<br><br>    scrollRef.current.current = { x: 0, y: 0 };<br>    scrollRef.current.target = { x: 0, y: 0 };<br>    scrollRef.current.last = { x: 0, y: 0 };<br><br>    if (containerRef.current) {<br>      containerRef.current.innerHTML = &quot;&quot;;<br>    }<br><br>    const baseItems = data.map((d, i) =&gt; {<br>      const scaleX = tileSizeRef.current.w / originalSize.w;<br>      const scaleY = tileSizeRef.current.h / originalSize.h;<br>      const source = sources[i % sources.length];<br>      return {<br>        src: source.src,<br>        caption: source.caption,<br>        x: d.x * scaleX,<br>        y: d.y * scaleY,<br>        w: d.w * scaleX,<br>        h: d.h * scaleY,<br>      };<br>    });<br><br>    itemsRef.current = [];<br>    const repsX = [0, tileSizeRef.current.w];<br>    const repsY = [0, tileSizeRef.current.h];<br><br>    baseItems.forEach((base) =&gt; {<br>      repsX.forEach((offsetX) =&gt; {<br>        repsY.forEach((offsetY) =&gt; {<br>          const el = document.createElement(&quot;div&quot;);<br>          el.classList.add(&quot;item&quot;);<br>          el.style.width = `${base.w}px`;<br><br>          const wrapper = document.createElement(&quot;div&quot;);<br>          wrapper.classList.add(&quot;item-wrapper&quot;);<br>          el.appendChild(wrapper);<br><br>          const itemImage = document.createElement(&quot;div&quot;);<br>          itemImage.classList.add(&quot;item-image&quot;);<br>          itemImage.style.width = `${base.w}px`;<br>          itemImage.style.height = `${base.h}px`;<br>          wrapper.appendChild(itemImage);<br><br>          const img = new Image();<br>          img.src = `./images/${base.src}`;<br>          itemImage.appendChild(img);<br><br>          const caption = document.createElement(&quot;small&quot;);<br>          caption.innerHTML = base.caption;<br><br>          // Simple fallback for SplitText (you can implement SplitText if you have access)<br>          wrapper.appendChild(caption);<br><br>          if (containerRef.current) {<br>            containerRef.current.appendChild(el);<br>          }<br><br>          if (observerRef.current) {<br>            observerRef.current.observe(caption);<br>          }<br><br>          itemsRef.current.push({<br>            el,<br>            container: itemImage,<br>            wrapper,<br>            img,<br>            x: base.x + offsetX,<br>            y: base.y + offsetY,<br>            w: base.w,<br>            h: base.h,<br>            extraX: 0,<br>            extraY: 0,<br>            rect: el.getBoundingClientRect(),<br>            ease: Math.random() * 0.5 + 0.5,<br>          });<br>        });<br>      });<br>    });<br><br>    tileSizeRef.current.w *= 2;<br>    tileSizeRef.current.h *= 2;<br><br>    scrollRef.current.current.x = scrollRef.current.target.x = scrollRef.current.last.x = -winSizeRef.current.w * 0.1;<br>    scrollRef.current.current.y = scrollRef.current.target.y = scrollRef.current.last.y = -winSizeRef.current.h * 0.1;<br>  }, [data, sources, originalSize]);</pre><h4>Handling User Interaction</h4><p>Now that the grid structure is ready, let’s talk about how user interactions are handled. We want the grid to respond smoothly whether the user scrolls with a mouse wheel or drags with a trackpad or mouse. There are two main interaction types here: <strong>scroll (wheel)</strong> and <strong>mouse drag</strong>.</p><h4>1. Wheel Handler</h4><p>The first function is the wheel handler. It listens to the wheel event and updates the scroll target values based on how much the user scrolls horizontally or vertically.</p><pre>const onWheel = useCallback((e: WheelEvent) =&gt; {<br>  e.preventDefault();<br>  const factor = 0.4;<br>  scrollRef.current.target.x -= e.deltaX * factor;<br>  scrollRef.current.target.y -= e.deltaY * factor;<br>}, []);</pre><p>Let’s break it down:</p><ul><li>e.preventDefault() stops the browser’s default scroll behavior, allowing us to handle movement manually.</li><li>The variable factor controls how sensitive the scroll feels. Smaller values mean slower movement, while larger values make the grid move faster</li><li>We subtract e.deltaX and e.deltaY (the scroll distances from the wheel or trackpad) to update our target scroll position.</li></ul><p>In short, when the user scrolls, this function shifts the grid’s <strong>target position</strong>, which will later be animated toward smoothly using GSAP.</p><h4>2. Mouse Handler</h4><p>Next, we handle mouse interactions.<br> There are three main mouse events we care about:</p><ul><li><strong>Mouse Down:</strong> when the user starts clicking or pressing the trackpad</li><li><strong>Mouse Move:</strong> while the user drags the mouse</li><li><strong>Mouse Up:</strong> when the user releases it</li></ul><p>Let’s go through them one by one.</p><p><strong>a. Mouse Down</strong></p><pre>const onMouseDown = useCallback((e: MouseEvent) =&gt; {<br>  e.preventDefault();<br>  isDraggingRef.current = true;<br>  document.documentElement.classList.add(&quot;dragging&quot;);<br>  mouseRef.current.press.t = 1;<br>  dragRef.current.startX = e.clientX;<br>  dragRef.current.startY = e.clientY;<br>  dragRef.current.scrollX = scrollRef.current.target.x;<br>  dragRef.current.scrollY = scrollRef.current.target.y;<br>}, []);</pre><p>When the user presses the mouse button:</p><ul><li>We prevent default behavior and mark that dragging has started (isDraggingRef.current = true).</li><li>We add a &quot;dragging&quot; class to the document so we can apply custom styles if needed (for example, changing the cursor).</li><li>We save the mouse’s starting position (startX, startY) and the current scroll position.<br> This way, we can later calculate how far the mouse has moved from its original point.</li></ul><p><strong>b. Mouse Up</strong></p><pre>const onMouseUp = useCallback(() =&gt; {<br>  isDraggingRef.current = false;<br>  document.documentElement.classList.remove(&quot;dragging&quot;);<br>  mouseRef.current.press.t = 0;<br>}, []);</pre><p>When the user releases the mouse button:</p><ul><li>We stop the dragging mode.</li><li>We remove the &quot;dragging&quot; class.</li><li>We reset the press state, which can later be used for easing or other visual feedback effects.</li></ul><p><strong>c. Mouse Move</strong></p><pre>const onMouseMove = useCallback((e: MouseEvent) =&gt; {<br>  mouseRef.current.x.t = e.clientX / winSizeRef.current.w;<br>  mouseRef.current.y.t = e.clientY / winSizeRef.current.h;<br><br>  if (isDraggingRef.current) {<br>    const dx = e.clientX - dragRef.current.startX;<br>    const dy = e.clientY - dragRef.current.startY;<br>    scrollRef.current.target.x = dragRef.current.scrollX + dx;<br>    scrollRef.current.target.y = dragRef.current.scrollY + dy;<br>  }<br>}, []);</pre><p>Here’s what’s happening:</p><ul><li>We constantly track the mouse position (x.t and y.t) as a normalized value between 0 and 1. This allows us to use it for effects later (like parallax depth).</li><li>If the user is dragging, we calculate how far they’ve moved (dx, dy) and update the scroll target accordingly.</li></ul><p>This creates a <strong>smooth drag-to-scroll</strong> experience, similar to what you see in design showcases or creative portfolio websites.</p><h4>Rendering</h4><p>The purpose of the rendering function is simple: to update and draw each frame on the screen. This is the main engine that allows our infinite grid to move, animate, and respond to user interaction in real time.</p><p>Let’s break down how it works.</p><h4>1. Smooth interpolation for movement</h4><p>The first few lines are all about making movement feel smooth. We calculate the difference between the <strong>target position</strong> and the <strong>current position</strong>, then move the current position a small step toward the target on every frame.</p><pre>scrollRef.current.current.x += (scrollRef.current.target.x - scrollRef.current.current.x) * scrollRef.current.ease;<br>scrollRef.current.current.y += (scrollRef.current.target.y - scrollRef.current.current.y) * scrollRef.current.ease;</pre><p>This gradual update is what gives that natural, easing motion when you scroll or drag.</p><p>Next, we calculate the difference between the current and last positions.<br>This gives us the scroll direction (for example, “right” or “left”), which we’ll use later to decide when to wrap items around the screen.</p><h4>2. Looping through each item</h4><p>After that, we loop through every item in our grid using forEach.<br> Inside this loop, several things happen:</p><ol><li><strong>Calculate parallax offset</strong><br>We determine a small offset for each item based on both scroll and mouse movement. <strong>This is what creates the parallax effect </strong>where items move slightly differently depending on their easing value.</li></ol><pre>const newX = 5 * scrollRef.current.delta.x.c * item.ease + (mouseRef.current.x.c - 0.5) * item.rect.width * 0.6;<br>const newY = 5 * scrollRef.current.delta.y.c * item.ease + (mouseRef.current.y.c - 0.5) * item.rect.height * 0.6;</pre><p><strong>2. Calculate position and apply infinite wrapping</strong><br> We figure out each item’s new position (posX, posY). Then, we check if an item has moved completely out of the viewport. If so, we shift it to the opposite side of the screen. This is the <strong>infinite scroll logic</strong> that keeps the grid looping forever.</p><pre>if (dirX === &quot;right&quot; &amp;&amp; beforeX) item.extraX -= tileSizeRef.current.w;<br>if (dirX === &quot;left&quot; &amp;&amp; afterX) item.extraX += tileSizeRef.current.w;<br>if (dirY === &quot;down&quot; &amp;&amp; beforeY) item.extraY -= tileSizeRef.current.h;<br>if (dirY === &quot;up&quot; &amp;&amp; afterY) item.extraY += tileSizeRef.current.h;</pre><p>3. <strong>Apply transforms to the DOM</strong><br>Finally, we apply the calculated position and parallax scaling directly to the DOM elements using CSS transforms. This keeps rendering fast and smooth since transforms are GPU-accelerated.</p><pre>item.el.style.transform = `translate(${fx}px, ${fy}px)`;<br>item.img.style.transform = `scale(${1.2 + 0.2 * mouseRef.current.press.c * item.ease})<br>  translate(${-mouseRef.current.x.c * item.ease * 10}%, ${-mouseRef.current.y.c * item.ease * 10}%)`;</pre><h4>3. Updating and looping again</h4><p>Once we’re done updating every item, we set the current position as the new “last position” and call requestAnimationFrame(render) to repeat the process on the next frame. This creates a continuous animation loop that updates roughly 60 times per second. And this is how the whole render function looks like</p><pre>const render = useCallback(() =&gt; {<br>    scrollRef.current.current.x += (scrollRef.current.target.x - scrollRef.current.current.x) * scrollRef.current.ease;<br>    scrollRef.current.current.y += (scrollRef.current.target.y - scrollRef.current.current.y) * scrollRef.current.ease;<br><br>    scrollRef.current.delta.x.t = scrollRef.current.current.x - scrollRef.current.last.x;<br>    scrollRef.current.delta.y.t = scrollRef.current.current.y - scrollRef.current.last.y;<br>    scrollRef.current.delta.x.c += (scrollRef.current.delta.x.t - scrollRef.current.delta.x.c) * 0.04;<br>    scrollRef.current.delta.y.c += (scrollRef.current.delta.y.t - scrollRef.current.delta.y.c) * 0.04;<br>    mouseRef.current.x.c += (mouseRef.current.x.t - mouseRef.current.x.c) * 0.04;<br>    mouseRef.current.y.c += (mouseRef.current.y.t - mouseRef.current.y.c) * 0.04;<br>    mouseRef.current.press.c += (mouseRef.current.press.t - mouseRef.current.press.c) * 0.04;<br><br>    const dirX = scrollRef.current.current.x &gt; scrollRef.current.last.x ? &quot;right&quot; : &quot;left&quot;;<br>    const dirY = scrollRef.current.current.y &gt; scrollRef.current.last.y ? &quot;down&quot; : &quot;up&quot;;<br><br>    itemsRef.current.forEach((item) =&gt; {<br>      const newX = 5 * scrollRef.current.delta.x.c * item.ease + (mouseRef.current.x.c - 0.5) * item.rect.width * 0.6;<br>      const newY = 5 * scrollRef.current.delta.y.c * item.ease + (mouseRef.current.y.c - 0.5) * item.rect.height * 0.6;<br>      const scrollX = scrollRef.current.current.x;<br>      const scrollY = scrollRef.current.current.y;<br>      const posX = item.x + scrollX + item.extraX + newX;<br>      const posY = item.y + scrollY + item.extraY + newY;<br><br>      const beforeX = posX &gt; winSizeRef.current.w;<br>      const afterX = posX + item.rect.width &lt; 0;<br>      if (dirX === &quot;right&quot; &amp;&amp; beforeX) item.extraX -= tileSizeRef.current.w;<br>      if (dirX === &quot;left&quot; &amp;&amp; afterX) item.extraX += tileSizeRef.current.w;<br><br>      const beforeY = posY &gt; winSizeRef.current.h;<br>      const afterY = posY + item.rect.height &lt; 0;<br>      if (dirY === &quot;down&quot; &amp;&amp; beforeY) item.extraY -= tileSizeRef.current.h;<br>      if (dirY === &quot;up&quot; &amp;&amp; afterY) item.extraY += tileSizeRef.current.h;<br><br>      const fx = item.x + scrollX + item.extraX + newX;<br>      const fy = item.y + scrollY + item.extraY + newY;<br>      item.el.style.transform = `translate(${fx}px, ${fy}px)`;<br>      item.img.style.transform = `scale(${<br>        1.2 + 0.2 * mouseRef.current.press.c * item.ease<br>      }) translate(${-mouseRef.current.x.c * item.ease * 10}%, ${<br>        -mouseRef.current.y.c * item.ease * 10<br>      }%)`;<br>    });<br><br>    scrollRef.current.last.x = scrollRef.current.current.x;<br>    scrollRef.current.last.y = scrollRef.current.current.y;<br><br>    animationRef.current = requestAnimationFrame(render);<br>  }, []);</pre><h3>Lifecycle Management</h3><p>We’re almost done! The final part of our setup is managing the <strong>component lifecycle</strong> and attaching event listeners. This is where we initialize everything, run our rendering engine, and clean up when the component unmounts.</p><p>Here’s the breakdown:</p><h4>1. Setting up event listeners and observers</h4><p>Inside the useEffect hook, we start by creating an <strong>Intersection Observer</strong> to detect when captions enter or leave the viewport. This allows us to toggle a visible class and animate them when they appear on screen.</p><p>Next, we attach all our event listeners:</p><ul><li>resize for triggers, the onResize function to recalculate the grid size.</li><li>wheel for listening to scroll movement.</li><li>mousemove, mouseup, and mousedown → handle mouse tracking and dragging.</li></ul><p>All those listeners ensure our grid stays interactive and responsive.</p><p>After setting up listeners, we call three functions:onResize() to build the initial grid based on the current screen size. render() to start the rendering loop.initIntro() to trigger the first intro animation. At this point, the grid should be fully visible and interactive</p><p>Finally, we clean up everything when the component unmounts:</p><ul><li>Remove all event listeners</li><li>Disconnect the Intersection Observer</li><li>Cancel the animation frame to stop the rendering loop</li></ul><p>This is important to <strong>prevent memory leaks </strong>and make sure your code runs efficiently even after navigating away from the page.</p><pre> useEffect(() =&gt; {<br>    const container = containerRef.current;<br><br>    // Initialize intersection observer<br>    observerRef.current = new IntersectionObserver((entries) =&gt; {<br>      entries.forEach((entry) =&gt; {<br>        entry.target.classList.toggle(&quot;visible&quot;, entry.isIntersecting);<br>      });<br>    });<br><br>    // Add event listeners<br>    window.addEventListener(&quot;resize&quot;, onResize);<br>    window.addEventListener(&quot;wheel&quot;, onWheel, { passive: false });<br>    window.addEventListener(&quot;mousemove&quot;, onMouseMove);<br>    window.addEventListener(&quot;mouseup&quot;, onMouseUp);<br><br>    if (container) {<br>      container.addEventListener(&quot;mousedown&quot;, onMouseDown);<br>    }<br><br>    // Initialize<br>    onResize();<br>    render();<br>    initIntro();<br><br>    // Cleanup<br>    return () =&gt; {<br>      window.removeEventListener(&quot;resize&quot;, onResize);<br>      window.removeEventListener(&quot;wheel&quot;, onWheel);<br>      window.removeEventListener(&quot;mousemove&quot;, onMouseMove);<br>      window.removeEventListener(&quot;mouseup&quot;, onMouseUp);<br><br>      if (container) {<br>        container.removeEventListener(&quot;mousedown&quot;, onMouseDown);<br>      }<br><br>      if (observerRef.current) {<br>        observerRef.current.disconnect();<br>      }<br><br>      if (animationRef.current) {<br>        cancelAnimationFrame(animationRef.current);<br>      }<br>    };<br>  }, [ onResize, onWheel, onMouseMove, onMouseDown, onMouseUp, render, initIntro,]);</pre><h4>Rendering Output</h4><p>Finally, we return the JSX that displays our grid on the screen.<br> Even though this part looks simple, it’s the container that holds all the dynamically generated elements we created in the previous steps.</p><pre>return (<br>    &lt;section className=&quot;relative w-full h-screen bg-primary-beige overflow-hidden&quot;&gt;<br>      &lt;div<br>        id=&quot;images&quot;<br>        ref={containerRef}<br>        className=&quot;relative w-full h-full overflow-hidden&quot;<br>      /&gt;<br>    &lt;/section&gt;<br>  );</pre><ul><li>The outer &lt;section&gt; acts as the main wrapper for this component.<br> It takes up the full width and height of the viewport (w-full h-screen) and has a beige background.<br> The overflow-hidden class ensures that any content moving beyond the viewport edges doesn’t show. This is especially important for our infinite parallax animation, since items are constantly moving in and out of view.</li><li>Inside the section, we have a &lt;div&gt; with the ID images.<br> This is where all of our grid items are rendered dynamically by JavaScript.<br> The ref={containerRef} connects this DOM element to our code so we can append images, wrappers, and captions directly into it.</li></ul><p>In other words, this &lt;div&gt; is the <em>stage</em>, and all the animations, mouse interactions, and infinite wrapping logic you’ve built happen right here.</p><p>This is the full code of how it looks.</p><pre>import { useEffect, useRef, useCallback, useMemo } from &quot;react&quot;;<br>import gsap from &quot;gsap&quot;;<br><br>interface GridItem {<br>  el: HTMLDivElement;<br>  container: HTMLDivElement;<br>  wrapper: HTMLDivElement;<br>  img: HTMLImageElement;<br>  x: number;<br>  y: number;<br>  w: number;<br>  h: number;<br>  extraX: number;<br>  extraY: number;<br>  rect: DOMRect;<br>  ease: number;<br>}<br><br>export default function ParallaxGrid() {<br>  const containerRef = useRef&lt;HTMLDivElement&gt;(null);<br>  const scrollRef = useRef({<br>    ease: 0.06,<br>    current: { x: 0, y: 0 },<br>    target: { x: 0, y: 0 },<br>    last: { x: 0, y: 0 },<br>    delta: { x: { c: 0, t: 0 }, y: { c: 0, t: 0 } },<br>  });<br>  const mouseRef = useRef({<br>    x: { t: 0.5, c: 0.5 },<br>    y: { t: 0.5, c: 0.5 },<br>    press: { t: 0, c: 0 },<br>  });<br>  const itemsRef = useRef&lt;GridItem[]&gt;([]);<br>  const observerRef = useRef&lt;IntersectionObserver | null&gt;(null);<br>  const animationRef = useRef&lt;number | null&gt;(null);<br>  const isDraggingRef = useRef(false);<br>  const dragRef = useRef({ startX: 0, startY: 0, scrollX: 0, scrollY: 0 });<br>  const tileSizeRef = useRef({ w: 0, h: 0 });<br>  const winSizeRef = useRef({ w: 0, h: 0 });<br><br>  // Grid data and sources from the original implementation<br>  const sources = useMemo(<br>    () =&gt; [<br>      {<br>        src: &quot;/work/desktop/aurora-desktop.webp&quot;,<br>        caption:<br>          &quot;Aurora &lt;br&gt;Creative Design Project &lt;br&gt;Modern Interface Design &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/elysian-desktop.webp&quot;,<br>        caption:<br>          &quot;Elysian &lt;br&gt;Brand Experience &lt;br&gt;Visual Identity System &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/lume-desktop.webp&quot;,<br>        caption:<br>          &quot;Lume &lt;br&gt;Digital Experience &lt;br&gt;User Interface Design &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/noir-desktop.webp&quot;,<br>        caption: &quot;Noir &lt;br&gt;Creative Process &lt;br&gt;Dark Theme Interface &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/serenity-desktop.webp&quot;,<br>        caption:<br>          &quot;Serenity &lt;br&gt;Minimal Design &lt;br&gt;Clean User Experience &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/aurora-desktop.webp&quot;,<br>        caption: &quot;Hero Image &lt;br&gt;Main Visual &lt;br&gt;Creative Direction &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/elysian-desktop.webp&quot;,<br>        caption:<br>          &quot;Introduction &lt;br&gt;About Our Studio &lt;br&gt;Creative Vision &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/lume-desktop.webp&quot;,<br>        caption:<br>          &quot;Studio Space &lt;br&gt;Creative Environment &lt;br&gt;Workspace Design &lt;br&gt;2024&quot;,<br>      },<br>      {<br>        src: &quot;work/desktop/serenity-desktop.webp&quot;,<br>        caption:<br>          &quot;Studio View &lt;br&gt;Team Collaboration &lt;br&gt;Creative Process &lt;br&gt;2024&quot;,<br>      },<br>    ],<br>    []<br>  );<br><br>  const data = useMemo(<br>    () =&gt; [<br>      { x: 71, y: 58, w: 400, h: 270 },<br>      { x: 211, y: 255, w: 540, h: 360 },<br>      { x: 631, y: 158, w: 400, h: 270 },<br>      { x: 1191, y: 245, w: 260, h: 195 },<br>      { x: 351, y: 687, w: 260, h: 290 },<br>      { x: 751, y: 824, w: 205, h: 154 },<br>      { x: 911, y: 540, w: 260, h: 350 },<br>      { x: 1051, y: 803, w: 400, h: 300 },<br>      { x: 71, y: 922, w: 350, h: 260 },<br>    ],<br>    []<br>  );<br><br>  const originalSize = useMemo(() =&gt; ({ w: 1522, h: 1238 }), []);<br><br>  const initIntro = useCallback(() =&gt; {<br>    if (!containerRef.current) return;<br><br>    const introItems = Array.from(<br>      containerRef.current.querySelectorAll(&quot;.item-wrapper&quot;)<br>    ).filter((item) =&gt; {<br>      const rect = item.getBoundingClientRect();<br>      return (<br>        rect.x &gt; -rect.width &amp;&amp;<br>        rect.x &lt; window.innerWidth + rect.width &amp;&amp;<br>        rect.y &gt; -rect.height &amp;&amp;<br>        rect.y &lt; window.innerHeight + rect.height<br>      );<br>    });<br><br>    introItems.forEach((item) =&gt; {<br>      const rect = item.getBoundingClientRect();<br>      const x = -rect.x + window.innerWidth * 0.5 - rect.width * 0.5;<br>      const y = -rect.y + window.innerHeight * 0.5 - rect.height * 0.5;<br>      gsap.set(item, { x, y });<br>    });<br><br>    gsap.to(introItems.reverse(), {<br>      duration: 2,<br>      ease: &quot;expo.inOut&quot;,<br>      x: 0,<br>      y: 0,<br>      stagger: 0.05,<br>    });<br>  }, []);<br><br>  const onResize = useCallback(() =&gt; {<br>    winSizeRef.current.w = window.innerWidth;<br>    winSizeRef.current.h = window.innerHeight;<br><br>    tileSizeRef.current = {            <br>      w: winSizeRef.current.w,<br>      h: winSizeRef.current.w * (originalSize.h / originalSize.w),<br>    };<br><br>    scrollRef.current.current = { x: 0, y: 0 };<br>    scrollRef.current.target = { x: 0, y: 0 };<br>    scrollRef.current.last = { x: 0, y: 0 };<br><br>    if (containerRef.current) {<br>      containerRef.current.innerHTML = &quot;&quot;;<br>    }<br><br>    const baseItems = data.map((d, i) =&gt; {<br>      const scaleX = tileSizeRef.current.w / originalSize.w;<br>      const scaleY = tileSizeRef.current.h / originalSize.h;<br>      const source = sources[i % sources.length];<br>      return {<br>        src: source.src,<br>        caption: source.caption,<br>        x: d.x * scaleX,<br>        y: d.y * scaleY,<br>        w: d.w * scaleX,<br>        h: d.h * scaleY,<br>      };<br>    });<br><br>    itemsRef.current = [];<br>    const repsX = [0, tileSizeRef.current.w];<br>    const repsY = [0, tileSizeRef.current.h];<br><br>    baseItems.forEach((base) =&gt; {<br>      repsX.forEach((offsetX) =&gt; {<br>        repsY.forEach((offsetY) =&gt; {<br>          const el = document.createElement(&quot;div&quot;);<br>          el.classList.add(&quot;item&quot;);<br>          el.style.width = `${base.w}px`;<br><br>          const wrapper = document.createElement(&quot;div&quot;);<br>          wrapper.classList.add(&quot;item-wrapper&quot;);<br>          el.appendChild(wrapper);<br><br>          const itemImage = document.createElement(&quot;div&quot;);<br>          itemImage.classList.add(&quot;item-image&quot;);<br>          itemImage.style.width = `${base.w}px`;<br>          itemImage.style.height = `${base.h}px`;<br>          wrapper.appendChild(itemImage);<br><br>          const img = new Image();<br>          img.src = `./images/${base.src}`;<br>          itemImage.appendChild(img);<br><br>          const caption = document.createElement(&quot;small&quot;);<br>          caption.innerHTML = base.caption;<br><br>          wrapper.appendChild(caption);<br><br>          if (containerRef.current) {<br>            containerRef.current.appendChild(el);<br>          }<br><br>          if (observerRef.current) {<br>            observerRef.current.observe(caption);<br>          }<br><br>          itemsRef.current.push({<br>            el,<br>            container: itemImage,<br>            wrapper,<br>            img,<br>            x: base.x + offsetX,<br>            y: base.y + offsetY,<br>            w: base.w,<br>            h: base.h,<br>            extraX: 0,<br>            extraY: 0,<br>            rect: el.getBoundingClientRect(),<br>            ease: Math.random() * 0.5 + 0.5,<br>          });<br>        });<br>      });<br>    });<br><br>    tileSizeRef.current.w *= 2;<br>    tileSizeRef.current.h *= 2;<br><br>    scrollRef.current.current.x =<br>      scrollRef.current.target.x =<br>      scrollRef.current.last.x =<br>        -winSizeRef.current.w * 0.1;<br>    scrollRef.current.current.y =<br>      scrollRef.current.target.y =<br>      scrollRef.current.last.y =<br>        -winSizeRef.current.h * 0.1;<br>  }, [data, sources, originalSize]);<br><br>  const onWheel = useCallback((e: WheelEvent) =&gt; {<br>    e.preventDefault();<br>    const factor = 0.4;<br>    scrollRef.current.target.x -= e.deltaX * factor;<br>    scrollRef.current.target.y -= e.deltaY * factor;<br>  }, []);<br><br>  const onMouseDown = useCallback((e: MouseEvent) =&gt; {<br>    e.preventDefault();<br>    isDraggingRef.current = true;<br>    document.documentElement.classList.add(&quot;dragging&quot;);<br>    mouseRef.current.press.t = 1;<br>    dragRef.current.startX = e.clientX;<br>    dragRef.current.startY = e.clientY;<br>    dragRef.current.scrollX = scrollRef.current.target.x;<br>    dragRef.current.scrollY = scrollRef.current.target.y;<br>  }, []);<br><br>  const onMouseUp = useCallback(() =&gt; {<br>    isDraggingRef.current = false;<br>    document.documentElement.classList.remove(&quot;dragging&quot;);<br>    mouseRef.current.press.t = 0;<br>  }, []);<br><br>  const onMouseMove = useCallback((e: MouseEvent) =&gt; {<br>    mouseRef.current.x.t = e.clientX / winSizeRef.current.w;<br>    mouseRef.current.y.t = e.clientY / winSizeRef.current.h;<br><br>    if (isDraggingRef.current) {<br>      const dx = e.clientX - dragRef.current.startX;<br>      const dy = e.clientY - dragRef.current.startY;<br>      scrollRef.current.target.x = dragRef.current.scrollX + dx;<br>      scrollRef.current.target.y = dragRef.current.scrollY + dy;<br>    }<br>  }, []);<br><br>  const render = useCallback(() =&gt; {<br>    scrollRef.current.current.x +=<br>      (scrollRef.current.target.x - scrollRef.current.current.x) *<br>      scrollRef.current.ease;<br>    scrollRef.current.current.y +=<br>      (scrollRef.current.target.y - scrollRef.current.current.y) *<br>      scrollRef.current.ease;<br><br>    scrollRef.current.delta.x.t =<br>      scrollRef.current.current.x - scrollRef.current.last.x;<br>    scrollRef.current.delta.y.t =<br>      scrollRef.current.current.y - scrollRef.current.last.y;<br>    scrollRef.current.delta.x.c +=<br>      (scrollRef.current.delta.x.t - scrollRef.current.delta.x.c) * 0.04;<br>    scrollRef.current.delta.y.c +=<br>      (scrollRef.current.delta.y.t - scrollRef.current.delta.y.c) * 0.04;<br>    mouseRef.current.x.c +=<br>      (mouseRef.current.x.t - mouseRef.current.x.c) * 0.04;<br>    mouseRef.current.y.c +=<br>      (mouseRef.current.y.t - mouseRef.current.y.c) * 0.04;<br>    mouseRef.current.press.c +=<br>      (mouseRef.current.press.t - mouseRef.current.press.c) * 0.04;<br><br>    const dirX =<br>      scrollRef.current.current.x &gt; scrollRef.current.last.x ? &quot;right&quot; : &quot;left&quot;;<br>    const dirY =<br>      scrollRef.current.current.y &gt; scrollRef.current.last.y ? &quot;down&quot; : &quot;up&quot;;<br><br>    itemsRef.current.forEach((item) =&gt; {<br>      const newX =<br>        5 * scrollRef.current.delta.x.c * item.ease +<br>        (mouseRef.current.x.c - 0.5) * item.rect.width * 0.6;<br>      const newY =<br>        5 * scrollRef.current.delta.y.c * item.ease +<br>        (mouseRef.current.y.c - 0.5) * item.rect.height * 0.6;<br>      const scrollX = scrollRef.current.current.x;<br>      const scrollY = scrollRef.current.current.y;<br>      const posX = item.x + scrollX + item.extraX + newX;<br>      const posY = item.y + scrollY + item.extraY + newY;<br><br>      const beforeX = posX &gt; winSizeRef.current.w;<br>      const afterX = posX + item.rect.width &lt; 0;<br>      if (dirX === &quot;right&quot; &amp;&amp; beforeX) item.extraX -= tileSizeRef.current.w;<br>      if (dirX === &quot;left&quot; &amp;&amp; afterX) item.extraX += tileSizeRef.current.w;<br><br>      const beforeY = posY &gt; winSizeRef.current.h;<br>      const afterY = posY + item.rect.height &lt; 0;<br>      if (dirY === &quot;down&quot; &amp;&amp; beforeY) item.extraY -= tileSizeRef.current.h;<br>      if (dirY === &quot;up&quot; &amp;&amp; afterY) item.extraY += tileSizeRef.current.h;<br><br>      const fx = item.x + scrollX + item.extraX + newX;<br>      const fy = item.y + scrollY + item.extraY + newY;<br>      item.el.style.transform = `translate(${fx}px, ${fy}px)`;<br>      item.img.style.transform = `scale(${<br>        1.2 + 0.2 * mouseRef.current.press.c * item.ease<br>      }) translate(${-mouseRef.current.x.c * item.ease * 10}%, ${<br>        -mouseRef.current.y.c * item.ease * 10<br>      }%)`;<br>    });<br><br>    scrollRef.current.last.x = scrollRef.current.current.x;<br>    scrollRef.current.last.y = scrollRef.current.current.y;<br><br>    animationRef.current = requestAnimationFrame(render);<br>  }, []);<br><br>  useEffect(() =&gt; {<br>    const container = containerRef.current;<br><br>    // Initialize intersection observer<br>    observerRef.current = new IntersectionObserver((entries) =&gt; {<br>      entries.forEach((entry) =&gt; {<br>        entry.target.classList.toggle(&quot;visible&quot;, entry.isIntersecting);<br>      });<br>    });<br><br>    // Add event listeners<br>    window.addEventListener(&quot;resize&quot;, onResize);<br>    window.addEventListener(&quot;wheel&quot;, onWheel, { passive: false });<br>    window.addEventListener(&quot;mousemove&quot;, onMouseMove);<br>    window.addEventListener(&quot;mouseup&quot;, onMouseUp);<br><br>    if (container) {<br>      container.addEventListener(&quot;mousedown&quot;, onMouseDown);<br>    }<br><br>    // Initialize<br>    onResize();<br>    render();<br>    initIntro();<br><br>    // Cleanup<br>    return () =&gt; {<br>      window.removeEventListener(&quot;resize&quot;, onResize);<br>      window.removeEventListener(&quot;wheel&quot;, onWheel);<br>      window.removeEventListener(&quot;mousemove&quot;, onMouseMove);<br>      window.removeEventListener(&quot;mouseup&quot;, onMouseUp);<br><br>      if (container) {<br>        container.removeEventListener(&quot;mousedown&quot;, onMouseDown);<br>      }<br><br>      if (observerRef.current) {<br>        observerRef.current.disconnect();<br>      }<br><br>      if (animationRef.current) {<br>        cancelAnimationFrame(animationRef.current);<br>      }<br>    };<br>  }, [<br>    onResize,<br>    onWheel,<br>    onMouseMove,<br>    onMouseDown,<br>    onMouseUp,<br>    render,<br>    initIntro,<br>  ]);<br><br>  return (<br>    &lt;section className=&quot;relative w-full h-screen bg-primary-beige overflow-hidden&quot;&gt;<br>      &lt;div<br>        id=&quot;images&quot;<br>        ref={containerRef}<br>        className=&quot;relative w-full h-full overflow-hidden&quot;<br>      /&gt;<br>    &lt;/section&gt;<br>  );<br>}</pre><p>Besides, we also need a little bit of CSS</p><pre>#images {<br>  width: 100%;<br>  height: 100vh;<br>  position: relative;<br>  overflow: hidden;<br>  user-select: none;<br>  cursor: grab;<br>}<br><br>.dragging #images {<br>  cursor: grabbing;<br>}<br><br>#images .item {<br>  position: absolute;<br>  top: 0;<br>  left: 0;<br>  will-change: transform;<br>  white-space: normal;<br>}<br><br>#images .item-wrapper {<br>  will-change: transform;<br>}<br><br>#images .item-image {<br>  overflow: hidden;<br>}<br><br>#images .item-image img {<br>  width: 100%;<br>  height: 100%;<br>  object-fit: cover;<br>  will-change: transform;<br>}<br><br>#images .item small {<br>  width: 100%;<br>  display: block;<br>  font-size: 0.8rem;<br>  line-height: 1.25;<br>  margin-top: 0.75rem;<br>  opacity: 0;<br>  transform: translateY(20px);<br>  transition: opacity 0.5s ease, transform 0.5s ease;<br>}<br><br>#images .item small.visible {<br>  opacity: 1;<br>  transform: translateY(0);<br>}<br><br>#images .item small .line-mask {<br>  overflow: hidden;<br>  transition: transform 2s cubic-bezier(0.77, 0, 0.175, 1);<br>}<br><br>#images .item small .line {<br>  transition: transform 2s cubic-bezier(0.77, 0, 0.175, 1);<br>}<br><br>#images .item small:not(.visible) .line-mask {<br>  transform: translateY(100%);<br>}<br><br>#images .item small:not(.visible) .line {<br>  transform: translateY(110%);<br>}</pre><h4><strong>Why GSAP</strong></h4><p>Lately, the world of frontend development has been going through a big shift with the rise of AI. There are now plenty of tools that can generate user interface elements with just a single click. But when it comes to creating something truly custom, especially for unique cases or designs that haven’t been done before, AI still has its limits.</p><p>That’s where GSAP often comes in. It gives developers full flexibility and control over animations, making it possible to craft interactive experiences that feel precise, intentional, and unique. It’s something that AI-generated code still struggles to achieve.</p><p>The gap between AI-generated animations and handcrafted ones is still quite wide. Sure, AI can handle basic layouts or simple transitions. But when you want an animation that feels smooth, responsive, and emotionally aligned with the user experience, GSAP still depends on human understanding and creative instinct.</p><p>Even if you rely on AI to help with your animation, you still need to understand the basics. You should know which keywords to use, how to debug the output, and how the animation flow is structured. Without that knowledge, it’s easy to get stuck with results that don’t behave or feel the way you intended.</p><p>In many ways, GSAP is one of those areas where putting in the extra effort really pays off. It is where skill, creativity, and a sense of motion design come together, because a good animation is never just about movement. It is about creating a feeling.</p><p>So, when does it actually make sense to use GSAP in your projects?</p><h4>When You Need To Use GSAP</h4><p>Not every frontend project needs GSAP. Even though it’s incredibly powerful, you’ll only feel its full potential when you truly need fine-grained control and smooth, precise motion.</p><p>If your animations are simple, like fades, slides, or hover effects, then CSS transitions or animations are usually more than enough. For component-based interactions in React, you might even prefer Framer Motion, since it integrates more easily with state and lifecycle events.</p><p>But GSAP really shines when you’re dealing with things like:</p><ul><li>Complex, multi-element timelines (for example, a sequence of animations that play when a page loads)</li><li>Scroll-based interactions such as parallax, reveal effects, or scroll-triggered animations.</li><li>Performance-heavy animations where CSS starts to feel sluggish or inconsistent across browsers.</li><li>Integrations with SVG, Canvas, or WebGL, where GSAP gives you precision and flexibility that native browser animations can’t match.</li></ul><p>So no, GSAP isn’t for every case. But when a project needs that human touch, something that feels crafted and alive, GSAP becomes almost irreplaceable. It gives you complete control over how, when, and how smoothly elements move and respond on the screen.</p><h4>Learning Curve and Mindset GSAP</h4><p>That being said, GSAP isn’t something you just pick up in an afternoon. One thing that often surprises developers (including me) when they first try GSAP is its steep learning curve. It’s not that the syntax is hard, but the way of thinking is just… different from regular animations.</p><p>GSAP isn’t just a tool to move elements from point A to point B. It teaches you how to think about <strong>time</strong> and <strong>rhythm</strong> in interactions. You start learning about concepts like timelines, stagger, and easing…things that go beyond the technical side and touch on the <em>feel</em> of the motion itself.</p><p>That’s when the mindset starts to shift. Instead of just making elements “move,” you begin to think about how each movement supports the story and emotion of the interface. When should an animation be fast? When should it pause for a bit? How can a transition make the flow feel smoother for the user?</p><p>It takes time, practice, and thousands of trial and error. Just like when we first started learning to code, no one becomes an expert on the first try. But the more you play around with GSAP, the sharper your instincts get at reading timing and rhythm.</p><h4>Conclusion</h4><p>Three months went by so fast. It feels like just yesterday I was sitting at my campus library, trying to calm my nerves on the first day. Now, I’m wrapping up this internship with a notebook full of lessons</p><p>The quote “when you become a developer, you’ll never stop learning” is completely true. Everything I learned in the past two years was only the foundation. This project pushed me to dive into libraries I had never used before, read documentation, and figure things out one step at a time.</p><p>One thing I really learned is that it&#39;s better to overcommunicate than to stay silent. Asking one more question, sharing one more thought/opinion, or giving a quick update can save a lot of time and confusion and get feedback faster.</p><p>The biggest challenge wasn’t the technology itself, but the mindset. I won’t lie, there were moments when I stared at the screen for hours, wondering if I’d ever figure it out. But every time I pushed through, I learned something new about the code and about myself. <strong>I got comfortable with being uncomfortable!</strong></p><p>How about you? Have you ever felt stuck while learning something new in frontend (or tech in general), and then had that small breakthrough moment when it finally clicked? I’d love to hear your story in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca11deb1239b" width="1" height="1" alt=""><hr><p><a href="https://blog.zero-one-group.com/intern-blog-series-how-i-built-an-infinite-parallax-grid-with-gsap-from-a-beginners-perspective-ca11deb1239b">Intern Blog Series: How I Built an Infinite Parallax Grid with GSAP (from a Beginner’s Perspective)</a> was originally published in <a href="https://blog.zero-one-group.com/">Zero One Group</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[There’s No Perfect Time]]></title>
            <link>https://daisythoughts.medium.com/theres-no-perfect-time-8bc179920798?source=rss-64894e44bf71------2</link>
            <guid isPermaLink="false">https://medium.com/p/8bc179920798</guid>
            <dc:creator><![CDATA[daisy ]]></dc:creator>
            <pubDate>Wed, 26 Feb 2025 10:05:20 GMT</pubDate>
            <atom:updated>2025-02-26T10:09:13.212Z</atom:updated>
            <content:encoded><![CDATA[<p>Ive been thinking about it for a while. Learning that new skill, revamping my personal website, and yada yada. Web3, blockchain, AI, GSAP, DevOps, or something else entirely. But every time i consider starting, that same voice creeps into my head: ”Maybe later. Maybe when I have more time. Maybe when I feel ready.” And just like that, another day slips by. Until today i read this book called Rework by Jason Fried &amp; David Heinemeier Hansson. Let me tell you something that might sting a little:</p><blockquote>There is no perfect time. There never was, and there never will be.</blockquote><p>It seems like im waiting for the right moment. But that day isn’t coming, well its <strong>never</strong> coming actually. It’s a lie we tell ourselves to avoid discomfort. The truth? <strong>I will always have an excuse :)</strong></p><ul><li>“I’m too young.” And? Someone younger is already doing it.</li><li>“I’m too old.” That’s just fear talking. Plenty of people reinvented themselves later in life.</li><li>“I’m too broke.” Knowledge is free if you know where to look, Nad.</li><li>“I’m too stupid.” No one starts as an expert. You get smarter by doing.</li></ul><p>Listen, you don’t need a sign from the universe. You don’t need someone’s permission. You just need to start.</p><p>“But starting something new is scary” I get it. Starting something new is intimidating. Our brain is wired to protect us from failure. But here’s what you need to understand, Nad: <strong>Failure isn’t the enemy. Inaction is</strong>. Right now, someone with fewer resources, more struggles, and less time than you is making it happen. They aren’t waiting. They’re starting, failing, learning, adjusting, and growing. And six months from now, they’ll be ahead while you’re still thinking about it, stuck in the same place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*Ymo7v6zNWGoPV5RCzXChwg.jpeg" /></figure><p>So stop waiting. Stop hesitating. Just start. You’ll figure it out as you go.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8bc179920798" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Feel Relieved Knowing That Life Is Uncertain]]></title>
            <link>https://daisythoughts.medium.com/feel-relieved-knowing-that-life-is-uncertain-02ac59ec5950?source=rss-64894e44bf71------2</link>
            <guid isPermaLink="false">https://medium.com/p/02ac59ec5950</guid>
            <category><![CDATA[life]]></category>
            <category><![CDATA[stoicism]]></category>
            <category><![CDATA[uncertainty-of-life]]></category>
            <category><![CDATA[self-acceptance]]></category>
            <dc:creator><![CDATA[daisy ]]></dc:creator>
            <pubDate>Mon, 24 Feb 2025 09:49:00 GMT</pubDate>
            <atom:updated>2025-02-24T09:58:29.192Z</atom:updated>
            <content:encoded><![CDATA[<p>Today, I went to college for my risk management class. The professor was teaching as usual until he wrote the word “uncertainty” on the whiteboard. He explained that we should prepare our goals as best as possible to minimize risks because uncertainty always exists.</p><p>At first, I used to see uncertainty as something to be afraid of. But the more I think about it, the more I realize that <strong>uncertainty is what makes us grow and learn.</strong> Not gonna lie, I still have moments where I’m scared of the unknown (Aren’t we all, Nad??) But I’ve come to understand that uncertainty is a natural part of life, and instead of resisting it, maybe we should embrace it. Life becomes more meaningful when we appreciate even the smallest things that happen unexpectedly.</p><p>Humans are wired to seek certainty, it’s in our nature. Our ancestors lived a nomadic life to ensure food stability until they discovered farming and livestock. <strong>Uncertainty pushed them to adapt and evolve.</strong> Well, no one wants to live in doubt, hesitation, or danger, but in reality, a completely predictable life is impossible. This world is designed to be full of surprises (which is probably why this course even exists, haha). Uncertainty can be scary, but at the same time, it’s what drives us forward.</p><p>I used to overthink a lot, constantly playing out <strong>“what if”</strong> scenarios in my head because of uncertainty. Then one day, I came across <strong>Stoicism</strong>, and it hit me “<strong>we can only control what we can control”</strong>. That changed everything.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/723/1*c6tCubt5UhtxBie_f4VhKA.jpeg" /></figure><p>Now, my life feels much lighter, and I can deal with uncertainty in every aspect of my life. I’ve learned that our tolerance for uncertainty can be trained. Instead of obsessing over the negative side, I started shifting my focus to the positive:</p><ul><li>Today was a bad day? Well, because life is unpredictable, maybe tomorrow will be better.</li><li>I feel grateful today? Since life is uncertain, I’ll probably find even more reasons to be grateful tomorrow.</li><li>My grades dropped, and I didn’t do well on an exam? It’s not the end — life is full of uncertainties, which means I still have the chance to fix my score.</li></ul><p><strong>Who says uncertainty always leads to bad things?</strong></p><p>No matter how much we prepare, <strong>life will always find a way to surprise us </strong>and that’s what makes it interesting. If everything in life went exactly as planned, wouldn’t it be boring? That being said, embracing uncertainty doesn’t mean we shouldn’t plan at all. We’ve all heard the phrase <strong>“sedia payung sebelum hujan” </strong>since kindergarten. It’s smart to have a backup plan, but we also have to accept that we <strong>CAN’T</strong> prepare for every single possibility.</p><p>Anyway, I wrote this article on the first day of my period, so maybe I’m just extra emotional today, haha. But if you’re someone who’s constantly afraid of taking chances, I hope this helps — even just a little.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=02ac59ec5950" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Learned to Live in the Present]]></title>
            <link>https://daisythoughts.medium.com/how-i-learned-to-live-in-the-present-d528dc97fe1a?source=rss-64894e44bf71------2</link>
            <guid isPermaLink="false">https://medium.com/p/d528dc97fe1a</guid>
            <category><![CDATA[social-media]]></category>
            <category><![CDATA[mindfulness]]></category>
            <category><![CDATA[self-awareness]]></category>
            <dc:creator><![CDATA[daisy ]]></dc:creator>
            <pubDate>Mon, 19 Aug 2024 04:46:54 GMT</pubDate>
            <atom:updated>2024-08-19T10:28:26.339Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ut23X-NmtNcZ_Gg6tCdW9A.png" /></figure><p>It was one of those day — boredom led me to mindlessly open Youtube. I clicked on random video popped up on my timeline. (I highly recommend you watch it too before you continue reading; trust me, it’ll set the tone. <a href="https://youtu.be/zIu7PtT79uA?si=PRZoWwSh4Y5riaLS">https://youtu.be/zIu7PtT79uA?si=PRZoWwSh4Y5riaLS</a> )</p><p>As the video played, a realization hit me: the past year of my life had slipped away, consumed by endless scrolling, liking, and commenting on social media. I was lost in a void, live a life without motivation. I just pretend and force my self doing motions — work, college, daily routines— but i wasn’t really living. The thought haunted me was “How long can i keep going like this?”</p><p>Social media is sucking the life out of me. My attention span was shrinking, making me nervous for no reason, keeping me fear of missing out. I found myself trapped in the comparison — me on day one vs others on day 100 — and it left me feeling ungrateful. The worst things is i couldn’t even stop. I began questioning my abilities, my worth and my value.</p><p>So, i deactivated my twitter and uninstalled tiktok without a second thought. The few days were strange — i found myself always ended up checking my phone again and again. Deep down, i knew i had to force myself to face the discomfort of boredom, something i’d always despised. One minute…three minutes…seven minutes passed. I grabbed a book from the shelf — a book i hadn’t touched in months.</p><p>As i turned each page, i began to notice the small details: the texture of the paper against my fingers, the gentle breeze brushing my face, the way my mind absorbed each word, processing the sentences. I started to feel this is me, myself, right now, is reading a book.</p><blockquote><strong>It sounds cliché, but i feel more alive than i had in a long time…</strong></blockquote><p>That’s when it hit me: i want to live my life fully aware of my existence. I don’t want to waste my precious time mindlessly scrolling through social media, lost in a sea of meaningless content. Instead, i have started focusing on whats happening right now, on what i can do in this every moment, rather than getting lost in the endless “what ifs” of the future. My mind used to be filled with questions like “what if i don’t succeed?” “what if i fail again?” “what if i had studied more that night to become a straight-A-student?” “what if i had taken that chance?” “what if i don’t get perfect grades this semester?”. But now, i’ve stopped caring so much about those hypothetical scenarios.</p><p>I have realized that the present is all i truly own. Worrying about the future won’t fix anything. Instead, i’m focusing on solving the problems of “right now” rather than stressing over the problem of tomorrow, next week, next month, or even next year. After all, how can i hope to solve those future problems if i waste my present worrying about them?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d528dc97fe1a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ngapain aja 6 bulan di ITS?]]></title>
            <link>https://daisythoughts.medium.com/ngapain-aja-6-bulan-di-its-6d9724d7403e?source=rss-64894e44bf71------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d9724d7403e</guid>
            <category><![CDATA[information-systems]]></category>
            <category><![CDATA[social]]></category>
            <category><![CDATA[college]]></category>
            <dc:creator><![CDATA[daisy ]]></dc:creator>
            <pubDate>Tue, 26 Mar 2024 04:41:33 GMT</pubDate>
            <atom:updated>2024-03-26T08:32:13.858Z</atom:updated>
            <content:encoded><![CDATA[<p>Kehidupan menjadi mahasiswa baru dimulai pada Agustus 2023. Aku berpindah dari Malang ke Surabaya. Beradaptasi dengan cuaca Surabaya menjadi tantangan pertamaku. Panas. Berbeda dengan cuaca Malang yang jauh lebih dingin (ya..meskipun kadang masih panas juga). Namun, daripada membahas cuaca, tulisan selanjutnya akan fokus pada kehidupan perkuliahan, sosial, pertemanan, dan sedikit romansa (mungkin).</p><p>Kehidupan perkuliahan membuat jiwa <em>introvert</em> ku berkurang drastis, hal yang tidak kusangka sangka adalah aku menjadi lebih<em> extrovert</em>. Aku menjadi lebih <em>excited</em> ketika diajak keluar untuk sekedar main/<em>hangout</em> dengan teman-teman. Berbeda dengan Nadia SMK, Nadia versi kuliah berhasil mendapatkan <em>circle</em> nya yang dia idam-idamkan ketika SMK. Nadia versi kuliah berhasil menjadi orang yang bisa memulai percakapan (walaupun terkadang masih <em>awkward</em>). Nadia versi kuliah berhasil bergaul dengan kakak tingkat di berbagai jurusan. Nadia versi kuliah berhasil berbaur dengan teman-teman seangkatannya baik dengan jurusan yang sama atau jurusan yang berbeda. Perkenalkan, 6 strangers yang berakhir menjadi teman dekat yang menemani kehidupan kuliah yang “tronjal tronjol” ini. <em>I do hit BFF jackpot!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jt2CmgXNj1xypB_rCnOw0A.jpeg" /></figure><p>Nadia dengan latar belakang SMK jurusan Rekayasa Perangkat Lunak sedikit banyak mengalami <em>culture shock</em> ketika menghadapi materi perkuliahan di Sistem Informasi. Manusia yang terbiasa <em>learn by practice </em>selama 3 tahun kebelakang ini dipaksa <em>learn by theory. </em>Disamping mengulang kembali materi pemrograman selama SMK, aku harus mulai membiasakan diri untuk membaca dan memahami buku tentang bisnis dan ekonomi related. Butuh waktu cukup lama untuk beradaptasi, <em>i do still struggling till now tho</em>... Mungkin akan aku ceritakan di postingan yang berbeda mengapa aku memilih sistem informasi dibanding teknik informatika yang lebih linear. <em>Lets put that aside</em>, Apakah aku merasa salah jurusan? Awalnya iya…sedikit…tapi, semenjak memasuki semester 2 ini aku yakin ini adalah jurusan yang tepat dengan apa yang aku inginkan, jurusan yang tepat untuk menggapai mimpi ku, jurusan yang tepat dengan apa yang menjadi passion ku.</p><p>Sementara semester I dipenuhi dengan materi bisnis dan ekonomi, jiwa programmerku meraung-raung ingin kembali menyentuh <em>visual studio code, </em>memperbaiki error pemrograman dan bertengkar dengan UI UX karena mereka membuat <em>design</em> yang menyusahkan <em>frontend developer </em>— <em>nah im kidding</em>. Disinilah aku memutuskan untuk mendaftar kepanitiaan, INILHOITS 2024 yang merupakan kepanitiaan paling besar di kampus ibu yang luhur ini. Aku merasa bahwa ini adalah salah satu keputusan terbaik yang aku buat di 2023. Banyak ilmu yang bisa aku dapat selama 6 bulan menjadi bagian INILHOITS 2024. Bagaimana implementasi <em>code</em> yang <em>clean</em> dan rapi, berdiskusi dan melakukan kolaborasi, bagaimana mengelola waktu ditengah-tengah kesibukan kuliah dan kepanitiaan, bagaimana me-<em>manage</em> orang lain, bagaimana memberikan instruksi dan arahan yang jelas, dan masih banyak lagi. INILHOITS 2024 menjadi kepanitiaan yang melelahkan dan menyenangkan di saat yang bersamaan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/951/1*ElJv3XGVtT066LhaUZTeFQ.jpeg" /></figure><p>Perkuliahan, pertemanan, dan kepanitiaan. <em>We talk about romance now?</em> Hahaha dengan cerita singkat yang aku tulis diatas, rasanya aku masih belum membutuhkan “<em>something romantic”</em> untuk sekarang. Aku punya teman-teman yang <em>supportif</em> dan bisa diminta bantuan kapan saja, aku punya kesibukan lain: kepanitiaan,<em> freelance</em> dan belajar, aku punya keluarga yang bisa menjadi tempat keluh kesah. Tidak bisa dipungkiri bahwa terkadang aku juga merasa kesepian dan butuh seseorang untuk berbagi cerita, tertawa bersama, atau sekadar keluar jalan-jalan mengelilingi Surabaya di malam hari. Namun aku sadar bahwa itu adalah perasaan<em> impulsive</em> yang sementara. Kesepian adalah bagian alami dari kehidupan manusia, dan kebutuhan tadi bisa terpenuhi melalui interaksi sehari-hari dengan teman-teman atau keluarga.</p><p>Enam bulan berada di Surabaya menjalani perkuliahan mengajarkanku banyak hal. Perjalanan masih panjang dan aku percaya bahwa sesuatu yang menjadi takdirku pasti akan datang kepadaku, dengan terus berjuang dan bersyukur atas apa yang telah ada, aku akan tetap melangkah maju dengan percaya diri. Terima kasih untuk orang-orang yang telah dan masih menjadi bagian dari kisahku. Semoga kita semua dapat terus tumbuh dan berkembang.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d9724d7403e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Meet Nadia Lovely]]></title>
            <link>https://daisythoughts.medium.com/meet-nadia-lovely-161b415ec164?source=rss-64894e44bf71------2</link>
            <guid isPermaLink="false">https://medium.com/p/161b415ec164</guid>
            <category><![CDATA[self]]></category>
            <dc:creator><![CDATA[daisy ]]></dc:creator>
            <pubDate>Mon, 27 Mar 2023 04:57:03 GMT</pubDate>
            <atom:updated>2023-03-27T04:57:03.472Z</atom:updated>
            <content:encoded><![CDATA[<h4>“Seriusan namanya Nadia Lovely?” “Kirain nickname doang, ternyata nama asli ya?”</h4><p>Begitulah reaksi kebanyakan orang ketika mendengar nama lengkapku. Dulu, aku benci dengan nama ku, kebanyakan teman-teman SD ku mengejek nama belakang ku dengan di plesetkan menjadi sesuatu yang jorok.</p><p>Namun, hal ini berubah semenjak aku masuk ke SMK. Teman, guru, dan orang lain menjadi lebih gampang mengenali diriku.<br>“Ooh yang namanya ada Lovely nya itu kan?”<br>Aku jadi gampang diingat dan seperti punya tempat tersendiri di ingatan mereka tentang nama ku.</p><p>Saat ini aku berada di kelas 12 SMK, tepatnya di SMK Telkom Malang, dengan jurusan Rekayasa Perangkat Lunak. Seperti kebanyakan anak semester akhir pada umumnya, aku mengalami kebingungan menentukan jalan apa yang harus aku ambil setelah kelulusan. Anak pertama perempuan yang menjadi “harapan” keluarga agar harus bisa sukses ini mengalami dilemma antara kuliah sambil bekerja atau kuliah sambil mengandalkan beasiswa yang tinggal sedikit lagi bisa aku raih (not sure i really can get it or nah, but wish me luck). Jangan ditanya kenapa aku bisa berada di situasi ini, akan aku jelaskan di lain tulisan.</p><p>Aku lumayan menyesali masa SMK ku yang terlihat monoton selama 3 tahun terakhir — makan, coding, lomba, tidur, repeat — . Kemana sisi extrovert ku semasa SMP menghilang? sisi dimana aku menjadi seseorang yang mudah bergaul, memulai percakapan, lebih percaya diri, dan tidak mudah awkward dengan situasi. Sisi dimana aku tidak takut menyapa orang yang aku kenal terlebih dahulu.</p><blockquote>Nasi sudah menjadi bubur — katanya</blockquote><p>Seharusnya aku bisa mengisi masa SMK ku menjadi sedikit lebih berwarna, main mengelilingi indahnya Malang dengan teman, menjadi anggota yang aktif bersuara di organisasi, atau bahkan memulai hobi baru.</p><p>Namun, sudah terlalu banyak waktu yang terbuang begitu saja. Aku menyadari bahwa “hidup itu singkat” bukan hanya sebuah klise belaka, melainkan sebuah kenyataan yang harus dihadapi dengan bijak. Aku harus mulai memikirkan langkah apa yang harus diambil setelah lulus nanti, agar penyesalan ini tidak terulang. Seperti yang dikatakan oleh William Penn</p><h3><strong>“Time is what we want most, but what we use worst.”</strong></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=161b415ec164" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>