Skip to content

UI Library for Design Engineers. Animated components and effects you can copy and paste into your apps. Free. Open Source.

fix: test static params blog

Dillion Verma056727037848
diff --git a/apps/www/app/(blog)/blog/page.tsx b/apps/www/app/(blog)/blog/page.tsx
index e82c806d..47f14bf9 100644
--- a/apps/www/app/(blog)/blog/page.tsx
+++ b/apps/www/app/(blog)/blog/page.tsx
@@ -12,6 +12,12 @@ import Link from "next/link";
import type { Blog, WithContext } from "schema-dts";
export const revalidate = false;
+export const dynamic = "force-static";
+export const dynamicParams = false;
+
+export function generateStaticParams() {
+ return [];
+}
const BLOG_DESCRIPTION =
"Latest articles about UI components, animations, and web development best practices.";
diff --git a/apps/www/content/blog/shadcn-ui.mdx b/apps/www/content/blog/shadcn-ui.mdx
index e831fd9a..22ff00d6 100644
--- a/apps/www/content/blog/shadcn-ui.mdx
+++ b/apps/www/content/blog/shadcn-ui.mdx
@@ -12,10 +12,11 @@ tags:
- tailwind css
- ui development
- radix ui
-publishedOn: '2025-09-20T06:47:16.79812+00:00'
+publishedOn: "2025-09-20T06:47:16.79812+00:00"
featured: true
---
-Here’s the simple truth about **Shadcn UI**: it is *not* a component library in the way you’re probably used to. Think of it less as a package you install and more as a collection of well-crafted, reusable components that you copy and paste directly into your project. This gives you complete ownership and control over every line of code.
+
+Here’s the simple truth about **Shadcn UI**: it is _not_ a component library in the way you’re probably used to. Think of it less as a package you install and more as a collection of well-crafted, reusable components that you copy and paste directly into your project. This gives you complete ownership and control over every line of code.
## What Is Shadcn UI and Why Does It Matter?
@@ -29,9 +30,9 @@ Shadcn UI completely sidesteps these problems with its unique 'copy-and-paste' p
This ownership model is the real game-changer and the core reason Shadcn UI is getting so much attention in modern web development. Because the components are just files in your own project, you can:
-* **Modify them freely:** Need to change styles, add new features, or strip out something you don’t need? Go for it. No complex workarounds required.
-* **Avoid dependency headaches:** There is no "shadcn-ui" package in your `package.json`. That means no breaking changes from library updates wrecking your project overnight.
-* **Ensure perfect consistency:** The components become a true part of your internal design system, perfectly aligned with your project's architecture from day one.
+- **Modify them freely:** Need to change styles, add new features, or strip out something you don’t need? Go for it. No complex workarounds required.
+- **Avoid dependency headaches:** There is no "shadcn-ui" package in your `package.json`. That means no breaking changes from library updates wrecking your project overnight.
+- **Ensure perfect consistency:** The components become a true part of your internal design system, perfectly aligned with your project's architecture from day one.
This approach isn't just a niche idea; it's catching on fast. Recent developer surveys show its adoption is climbing, with one Stack Overflow report noting it's already used by nearly **8.7%** of developers in its category. This reflects a bigger shift in the community toward tools that give developers more control and lead to better-performing applications. You can dig into the full survey details at [Stack Overflow's 2025 Developer Survey](https://survey.stackoverflow.co/2025/).
@@ -45,20 +46,20 @@ To make this crystal clear, here’s a quick breakdown of its core principles.
This table sums up the fundamental ideas that make Shadcn UI so different from the libraries you might be used to.
-| Principle | What It Means for Developers |
-| :--- | :--- |
-| **Not a Library** | You get source code, not a dependency. This means no versioning conflicts or unexpected updates breaking your build. |
-| **Code Ownership** | You have **100% control** to edit, restyle, and refactor components to fit your exact needs. |
-| **Composition** | Components are built on unstyled, accessible primitives, giving you a solid, flexible foundation to build upon. |
-| **CLI-Driven** | A simple command-line tool lets you add the components you need, one at a time, without any manual setup fuss. |
+| Principle | What It Means for Developers |
+| :----------------- | :------------------------------------------------------------------------------------------------------------------- |
+| **Not a Library** | You get source code, not a dependency. This means no versioning conflicts or unexpected updates breaking your build. |
+| **Code Ownership** | You have **100% control** to edit, restyle, and refactor components to fit your exact needs. |
+| **Composition** | Components are built on unstyled, accessible primitives, giving you a solid, flexible foundation to build upon. |
+| **CLI-Driven** | A simple command-line tool lets you add the components you need, one at a time, without any manual setup fuss. |
<br />
Ultimately, these principles put the power back in your hands, letting you build what you want, how you want.
-To really *get* Shadcn UI, you have to look past the components themselves and understand the philosophy behind it all. It’s a deliberate break from how we’ve traditionally used UI libraries, and it’s all built around one powerful idea: **you should own your code**, not just rent it from a package. This principle of **code ownership** is the secret sauce to building more flexible, maintainable, and future-proof projects.
+To really _get_ Shadcn UI, you have to look past the components themselves and understand the philosophy behind it all. It’s a deliberate break from how we’ve traditionally used UI libraries, and it’s all built around one powerful idea: **you should own your code**, not just rent it from a package. This principle of **code ownership** is the secret sauce to building more flexible, maintainable, and future-proof projects.
-Most UI libraries get installed as a single, monolithic package from npm. When you do that, you're essentially plugging a black box into your application. Sure, you can use its components, but they aren't *truly* yours. This creates a dependency that can, and often does, cause major headaches down the road.
+Most UI libraries get installed as a single, monolithic package from npm. When you do that, you're essentially plugging a black box into your application. Sure, you can use its components, but they aren't _truly_ yours. This creates a dependency that can, and often does, cause major headaches down the road.
This is where the dreaded "dependency hell" rears its ugly head. We've all been there—wrestling with a library update that breaks everything, or hitting a wall because a component just doesn't quite match the design spec. The typical fix involves messy CSS overrides or convoluted workarounds that make your codebase brittle and a pain to manage.
@@ -66,13 +67,13 @@ This is where the dreaded "dependency hell" rears its ugly head. We've all been
### From Consumer to Creator
-Shadcn UI flips this entire model on its head. Instead of an install, you use a simple CLI command to copy a component's source code directly into your project's `components` folder. This simple act transforms you from a library *consumer* into a code *owner*. The components become a first-class part of your application, no different from any other file you’ve written yourself.
+Shadcn UI flips this entire model on its head. Instead of an install, you use a simple CLI command to copy a component's source code directly into your project's `components` folder. This simple act transforms you from a library _consumer_ into a code _owner_. The components become a first-class part of your application, no different from any other file you’ve written yourself.
That might sound like a small change, but the ripple effects on your workflow are huge:
-* **No More Fighting Abstractions:** You're not stuck working within the confines of a library's API or theming system. You have direct access to the component's JSX and [Tailwind CSS](https://tailwindcss.com/) classes, so you can make any change you need without fighting the framework.
-* **Zero External Dependencies:** Because there’s no `shadcn-ui` package in your `package.json`, your project is completely insulated from outside versioning conflicts. You decide when and if a component ever gets updated.
-* **True Customization:** The components are intentionally unopinionated. They give you a beautifully crafted and accessible starting point, but the final look, feel, and function are completely in your hands.
+- **No More Fighting Abstractions:** You're not stuck working within the confines of a library's API or theming system. You have direct access to the component's JSX and [Tailwind CSS](https://tailwindcss.com/) classes, so you can make any change you need without fighting the framework.
+- **Zero External Dependencies:** Because there’s no `shadcn-ui` package in your `package.json`, your project is completely insulated from outside versioning conflicts. You decide when and if a component ever gets updated.
+- **True Customization:** The components are intentionally unopinionated. They give you a beautifully crafted and accessible starting point, but the final look, feel, and function are completely in your hands.
This philosophy gives you the power to build durable, adaptable user interfaces that are perfectly suited to your project. You’re not just borrowing components; you’re using high-quality blueprints to build your own design system.
@@ -153,9 +154,9 @@ This unique architecture has made Shadcn UI a go-to for projects where flexibili
The synergy between Radix, Tailwind, and the CLI offers some clear advantages over the old way of doing things.
-* **Maximum Control:** With the source code living in your project, you have the final say over every pixel and every interaction.
-* **Minimal Bundle Size:** You only add the components you actually need. This means no shipping unused code to the client, which leads to better tree-shaking and a leaner final bundle.
-* **Future-Proof Architecture:** Your UI isn't tied to an external library's release schedule. This insulates your project from breaking changes and ensures things stay stable for the long haul.
+- **Maximum Control:** With the source code living in your project, you have the final say over every pixel and every interaction.
+- **Minimal Bundle Size:** You only add the components you actually need. This means no shipping unused code to the client, which leads to better tree-shaking and a leaner final bundle.
+- **Future-Proof Architecture:** Your UI isn't tied to an external library's release schedule. This insulates your project from breaking changes and ensures things stay stable for the long haul.
Ultimately, these technical perks translate into a better developer experience and a faster end product. You get all the benefits of a well-designed component system without giving up the freedom to build things your way.
@@ -195,13 +196,13 @@ To really nail down the differences, let's look at the key criteria that develop
### Shadcn UI vs Traditional UI Libraries
-| Feature | Shadcn UI | Material UI / Chakra UI |
-| :----------------------- | :----------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------- |
-| **Dependency Model** | Code is copied into your project; no external dependency in `package.json`. | Installed as a versioned npm package, creating a direct dependency. |
-| **Customization** | Direct manipulation of JSX and Tailwind CSS classes within the component file. | Primarily through a theme provider, component props, and style override APIs. |
-| **Bundle Size Impact** | Minimal. You only add the components you use, leading to excellent tree-shaking. | Can be larger, as the entire library is a dependency, though tree-shaking helps. |
-| **Updating Components** | Manual process. You use a CLI to `diff` changes and decide whether to apply them. | Managed via `npm update`. Can introduce breaking changes between major versions. |
-| **Developer Experience** | High control and transparency. Feels like writing your own components from a template. | Structured and guided. Easier for teams who prefer a consistent, documented API. |
+| Feature | Shadcn UI | Material UI / Chakra UI |
+| :----------------------- | :------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------- |
+| **Dependency Model** | Code is copied into your project; no external dependency in `package.json`. | Installed as a versioned npm package, creating a direct dependency. |
+| **Customization** | Direct manipulation of JSX and Tailwind CSS classes within the component file. | Primarily through a theme provider, component props, and style override APIs. |
+| **Bundle Size Impact** | Minimal. You only add the components you use, leading to excellent tree-shaking. | Can be larger, as the entire library is a dependency, though tree-shaking helps. |
+| **Updating Components** | Manual process. You use a CLI to `diff` changes and decide whether to apply them. | Managed via `npm update`. Can introduce breaking changes between major versions. |
+| **Developer Experience** | High control and transparency. Feels like writing your own components from a template. | Structured and guided. Easier for teams who prefer a consistent, documented API. |
<br />
@@ -225,18 +226,18 @@ npx shadcn-ui@latest init
Running this command starts a short, interactive Q&A session to get everything configured just right for your project. It’ll ask you about things like:
-* Your language of choice: **TypeScript** or **JavaScript**.
-* The visual style you're going for: `Default` or `New York`.
-* Your base color preference: `Slate`, `Gray`, `Zinc`, you name it.
-* Where your `globals.css` file lives, so it knows where to drop in the necessary Tailwind variables.
-* If you want to use CSS variables for theming.
-* Path aliases for your components (it usually defaults to `@/components`).
+- Your language of choice: **TypeScript** or **JavaScript**.
+- The visual style you're going for: `Default` or `New York`.
+- Your base color preference: `Slate`, `Gray`, `Zinc`, you name it.
+- Where your `globals.css` file lives, so it knows where to drop in the necessary Tailwind variables.
+- If you want to use CSS variables for theming.
+- Path aliases for your components (it usually defaults to `@/components`).
Once you’ve answered the prompts, the script does all the heavy lifting. It creates a `components.json` file to keep track of your setup, tweaks your `tailwind.config.js`, and adds the right styles to your global CSS file. This completely sidesteps all the tedious manual configuration. If you're new to this styling approach, our guide on how to [install Tailwind CSS in a React project](https://magicui.design/blog/install-tailwind-react) is a great place to get up to speed.
### Adding Your First Component
-With the setup out of the way, your project is primed and ready for components. This is where you really see the core idea of Shadcn UI in action. You don't *import* components from a package; you use the CLI to pull their actual source code right into your project.
+With the setup out of the way, your project is primed and ready for components. This is where you really see the core idea of Shadcn UI in action. You don't _import_ components from a package; you use the CLI to pull their actual source code right into your project.
Let's start with a classic UI element: a button.
@@ -280,7 +281,7 @@ There's no wrestling with complex theming APIs or fighting specificity with styl
When you're building software with a team, consistency isn't just a nice-to-have; it's everything. This is where Shadcn UI's unique approach really starts to pay off, especially in collaborative settings. It acts as the ultimate bridge between designers and developers by establishing a single source of truth.
-How? By placing component source code *directly inside your project repository*. This simple idea completely gets rid of the guesswork that so often slows down team workflows. Every developer on the team pulls from the exact same set of component files, guaranteeing that UI elements look and behave the same across the entire application.
+How? By placing component source code _directly inside your project repository_. This simple idea completely gets rid of the guesswork that so often slows down team workflows. Every developer on the team pulls from the exact same set of component files, guaranteeing that UI elements look and behave the same across the entire application.
This direct ownership also makes version control a breeze. Forget about the headache of managing updates from an external UI library. With Shadcn UI, any change to a component is tracked through Git, just like the rest of your project's code. This creates a transparent history, making it dead simple to see who changed what and why.
@@ -288,7 +289,7 @@ That shared codebase quickly becomes the foundation of a living, breathing desig
### Building a Cohesive Design Language
-A design system is so much more than a folder of components—it's the shared language your team uses to build products. Because your team *owns* the Shadcn UI components, you can adapt them perfectly to your evolving brand guidelines without battling the constraints of an external library.
+A design system is so much more than a folder of components—it's the shared language your team uses to build products. Because your team _owns_ the Shadcn UI components, you can adapt them perfectly to your evolving brand guidelines without battling the constraints of an external library.
Imagine this workflow: a designer requests a tweak to a button's hover state. A developer can jump right into that button's file, make the change, and the update is instantly available for everyone on the team. No silos, no friction.
@@ -330,6 +331,6 @@ This is where it truly shines. Customizing a component is as direct as it gets.
There are no complicated theming APIs, style overrides, or layers of abstraction to fight with. If you know Tailwind, you already know how to customize every single part of a **shadcn ui** component.
-***
+---
-Ready to build beautiful, high-performance web interfaces in minutes? **Magic UI** offers a massive library of over **50+** customizable blocks, templates, and **150+** free animated components built with React, TypeScript, and Tailwind CSS. Check out our collection and start building your next stunning landing page at [https://magicui.design](https://magicui.design).
\ No newline at end of file
+Ready to build beautiful, high-performance web interfaces in minutes? **Magic UI** offers a massive library of over **50+** customizable blocks, templates, and **150+** free animated components built with React, TypeScript, and Tailwind CSS. Check out our collection and start building your next stunning landing page at [https://magicui.design](https://magicui.design).