Our Tech Stack in 2025: Nuxt, GSAP & Beyond

Every studio has opinions about tools. Ours are shaped less by hype and more by what survives real client work. A good stack should help us move quickly, keep performance under control and make future maintenance easier, not harder.

In 2025, our web development stack is built around Nuxt, GSAP, Three.js, Spline and a small set of supporting tools that we trust. None of them are chosen because they are trendy. They are chosen because they help us ship polished digital experiences without fighting the foundation.

Why Nuxt is still our default

Nuxt gives us server-side rendering, file-based routing, content workflows, image handling and a strong module ecosystem. For the kind of brand websites and editorial experiences we build, that combination is hard to beat.

The biggest advantage is how quickly a project can move from idea to production. Routing, metadata, content and performance basics are already part of the framework. That lets us spend more time on the experience itself and less time wiring together infrastructure.

Nuxt also gives clients a practical path forward. A site should not become impossible to update after launch. Content, pages and components need to stay understandable for the next person who works on the project.

Why we use GSAP for animation

GSAP remains the animation tool we trust most. It handles timelines, scroll-driven animation and complex transitions with a level of control that CSS alone does not always provide.

We still use CSS transitions where they make sense. Simple hover states, opacity changes and small UI movements do not need a JavaScript animation library. But when a page needs precise sequencing, scroll triggers or a custom transition, GSAP is usually the better choice.

The reason is reliability. Animation bugs are easy to feel and hard to ignore. A small timing issue can make a site feel cheap. GSAP gives us enough control to tune motion properly.

3D with Three.js and Spline

For interactive 3D, we usually work with either Three.js or Spline. Three.js gives us low-level control when performance, custom shaders or advanced interaction matter. Spline is useful when the goal is to move quickly with a more visual authoring workflow.

The choice depends on the project. Some sites need highly optimized custom 3D. Others need a strong visual moment that can be designed and iterated quickly. The tool should match the job, not the other way around.

What we avoid

We try to avoid stacks that optimize for developer novelty over shipping. Every dependency is a future migration. Every abstraction is a future bug. If a boring tool solves the problem well, we usually choose the boring tool.

That does not mean we avoid new technology. It means we test it against real requirements: performance, accessibility, maintainability and client needs after launch.

The stack is only useful if the site works

A tech stack is not the product. The product is the site people use. The stack is only successful if the website loads quickly, feels clear, is easy to update and supports the brand.

That is the standard we care about. Nuxt, GSAP, Three.js and Spline are simply the tools that help us reach it more often.