---
title: Your first component
description: "A component is a function that returns JSX. Write one, nest it, style it and give it props, with examples you can edit and run."
section: Learn
order: 1
---

# Your first component

A Sluurp app is made of React components: functions that return what to show, written in JSX. Every example on these pages runs as you edit it.

**In this lesson**

- how to write a component and use it inside another;
- how JSX differs from HTML;
- how to style with Tailwind classes;
- how to pass a component values with props.

## A component is a function

```tsx try
export default function App() {
  return <h1 className="text-2xl font-semibold">Hello, world</h1>;
}
```

Change the text and the result follows. Three things to notice:

- A component's name starts with a capital letter: `App`, `Card`, `PostList`. That's how JSX tells your component from an HTML tag like `<h1>`.
- It returns JSX: markup inside JavaScript. Bun compiles it as the app is served, so nothing has to be set up.
- `export default` is the component this example shows. In an app, you export your components from their own files and import them where they're used.

## Components inside components

A component is used like a tag. Give it a closing slash when it has nothing inside: `<Avatar />`.

```tsx try
function Avatar() {
  return <div className="grid size-10 place-items-center rounded-full bg-sky-100 font-medium text-sky-700">AL</div>;
}

export default function App() {
  return (
    <div className="flex items-center gap-3">
      <Avatar />
      <div>
        <p className="font-medium">Ada Lovelace</p>
        <p className="text-sm text-muted-foreground">Mathematician</p>
      </div>
    </div>
  );
}
```

## JSX in a few rules

- **One parent.** A component returns one element. Several sit in a `<div>`, or in `<>…</>` when no element should wrap them.
- **Every tag is closed:** `<img />`, `<br />`, `<input />`.
- **Curly braces hold JavaScript:** `<p>{1 + 1}</p>` shows `2`, and `<img src={user.photo} />` takes a value.
- **`className`, not `class`,** and `htmlFor` instead of `for`: JSX uses the names JavaScript gives them.
- **Events are attributes that start with `on`:** `onClick={() => …}`. More in [Events and forms](/docs/learn/events-and-forms).

## Styling

Tailwind classes work in every file with no setup: the server makes the CSS for the classes your code uses. [Components](/docs/components) brings ready ones, buttons, inputs, dialogs and more, styled the same way.

```tsx try
import { Button } from "@/components/ui/button";

export default function App() {
  return (
    <div className="flex flex-wrap items-center gap-2">
      <Button>Save</Button>
      <Button variant="outline">Cancel</Button>
      <Button variant="ghost">Later</Button>
    </div>
  );
}
```

### Combining classes with `cn`

`cn` builds a class string from pieces. It does two things:

- **It joins.** Pass strings, conditions, arrays or objects. Falsy values are dropped, and an object's keys are kept where their value is true.
- **It resolves conflicts.** When two classes set the same thing, the last one wins: `cn("px-2", "px-4")` gives `"px-4"`. Without this, which one applies would depend on the order of the stylesheet, not on yours.

```ts
import { cn } from "cn";

cn("rounded-md px-3", "font-medium");                // "rounded-md px-3 font-medium"
cn("px-3", isActive && "bg-primary text-white");      // the second part only while isActive is true
cn("px-3", { "opacity-50": disabled, ring: focused }); // each key kept when its value is true
cn("p-4 text-sm", "p-2");                             // "text-sm p-2": the later padding wins
cn("px-2 hover:px-4", "px-6");                        // "hover:px-4 px-6": a variant is separate
```

This is what lets a component take a `className` from whoever uses it and let it win over its own defaults:

```tsx try
import { useState } from "react";
import { cn } from "cn";

function Tag({ className, children }) {
  return <span className={cn("rounded-full bg-muted px-3 py-1 text-sm", className)}>{children}</span>;
}

export default function App() {
  const [on, setOn] = useState(false);
  return (
    <div className="flex flex-wrap gap-2">
      <Tag>Default</Tag>
      <Tag className="bg-sky-100 text-sky-800">Coloured</Tag>
      <Tag className="px-12">Wider</Tag>
      <button className={cn("px-3 py-1 text-sm", on ? "bg-emerald-600 text-white" : "bg-muted")} onClick={() => setOn(!on)}>
        {on ? "On" : "Off"}
      </button>
    </div>
  );
}
```

`bg-sky-100` replaces the tag's `bg-muted`, and `px-12` replaces its `px-3`, while the rest stays. The components work the same way, so `<Button className="w-full">` widens a button without losing its look. See [Styling and Tailwind](/docs/styling).

## Props

A component receives values from the one that uses it, as attributes. They arrive together as its first argument, usually destructured right away:

```tsx try
function Greeting({ name, excited = false }) {
  return <p className="text-lg">Hello, {name}{excited ? "!" : "."}</p>;
}

export default function App() {
  return (
    <div>
      <Greeting name="Ada" />
      <Greeting name="Grace" excited />
    </div>
  );
}
```

- `excited = false` is used when no `excited` is given.
- `excited` written alone means `excited={true}`.

More in [Props and children](/docs/learn/props).

## Where components go

In an app, a component lives in its own `.tsx` file and is imported where it's used:

```tsx title="components/greeting.tsx"
export function Greeting({ name }) {
  return <p>Hello, {name}.</p>;
}
```

```tsx title="routes/index.tsx"
import { Greeting } from "@/components/greeting";

export default () => <Greeting name="Ada" />;
```

A page in `routes/` is drawn on the server; a component that changes in the browser says `"use client"` at its top. See [Server components](/docs/server-components).

Next: make something change on screen, with [state](/docs/learn/state).
