goltUI

goltUI is a copy-paste UI library. There is no runtime package to depend on — the CLI writes each component's real source into your project, installs whatever npm packages it needs, and leaves you to edit the code freely.

The repo is a Turborepo monorepo with two publishable pieces:

• Features
• Tech Stack
• Repository Structure
• Getting Started
• CLI
• Component Catalog
• Adding a Component
• Deployment
• Attribution
• Contributing
• License

• You own the code — components are copied as source into components/goltui/, not installed as an opaque dependency.
• Zero-config CLI — no init, no config file. It detects your package manager and whether you use a src/ layout.
• 25 production-ready components & blocks — buttons, inputs, heroes, logo clouds, auth layouts, headers, loaders, cursor and sound effects.
• Motion-first — built with Framer Motion springs, layout and exit animations.
• Accessible & responsive — keyboard-friendly, mobile-ready, dark theme by default.
• Strictly typed — TypeScript throughout, Tailwind CSS v4, React 19, Next.js 16.
• Automatic dependency install — the CLI runs bun add / pnpm add / yarn add / npm install for you.

goltUI/
├── apps/
│   └── web/                    # Next.js site (docs, gallery, blocks, /play game)
│       └── src/
│           ├── app/            # App Router routes
│           │   ├── components/ # Component gallery + per-component docs
│           │   ├── blocks/     # Block pages (+ [slug] "coming soon" fallback)
│           │   ├── docs/       # Introduction & guides
│           │   ├── play/       # Playable Framer Motion game
│           │   └── preview/    # Full-page component previews
│           ├── components/     # The actual component source
│           └── lib/            # Shared data (e.g. block categories)
└── packages/
    └── cli/                    # Published npm package: `goltui`
        ├── bin/goltui.js       # CLI entry point
        └── registry/           # Component source + registry.json (what the CLI copies)

Note: packages/cli/registry/ mirrors component source from apps/web. When you add a component, add it to both (see Adding a Component).

• Node.js ≥ 20 (this repo is developed on Node 22)

• Bun ≥ 1.3 — the package manager of record (bun.lock)

  _{npm, pnpm, and yarn work too, but Bun is what the lockfile and CI assume.}

git clone https://github.com/sudoKrishna/goltUI.git
cd goltUI
bun install
bun run dev          # starts apps/web at http://localhost:3000

cd apps/web
bun dev        # http://localhost:3000
bun build      # next build
bun start      # serve the production build

The goltui CLI copies component source straight into your project.

# install a component (run in your own Next.js + Tailwind project)
npx goltui add input-mic

# see everything available
npx goltui

What it does, in order:

1. Looks up the component in the bundled registry.
2. Copies its file(s) into components/goltui/… — or src/components/goltui/… if your project has a src/ directory. Existing files are skipped, never overwritten.
3. Copies any bundled assets into public/.
4. Installs the component's npm dependencies using the package manager it detects from your lockfile.
5. Prints the exact import to paste.

No init step. No config. No package added to your dependencies.

The CLI is self-contained — it ships its own registry and never calls the website or an API. Publishing new components means publishing a new CLI version.

Install any of these with npx goltui add <name>.

1. Build it in apps/web/src/components/<name> and add a docs page under apps/web/src/app/components/<slug>.

2. Copy the source into packages/cli/registry/<slug>/.

3. Register it in packages/cli/registry/registry.json:

   {
     "my-component": {
       "description": "One-line description shown by the CLI.",
       "dependencies": ["framer-motion"],
       "files": [
         { "source": "my-component/index.ts", "target": "components/goltui/my-component/index.ts" }
       ]
     }
   }

   • files[] — source is relative to packages/cli/registry/; target is relative to the consumer's project (src/ is added automatically when present).

   • assets[] — optional; always resolved from the consumer's project root.

   • import — optional override for the printed import when the slug doesn't map cleanly:

     "import": { "name": "{ MyComponent }", "path": "@/components/goltui/my-component" }

4. Test it against a scratch project before publishing:

   mkdir /tmp/goltui-test && cd /tmp/goltui-test && echo '{}' > package.json && mkdir src
   node /path/to/goltUI/packages/cli/bin/goltui.js add my-component

The two artifacts deploy independently.

1. Import the repository into Vercel.
2. Set Root Directory to apps/web.
3. Framework preset Next.js (auto-detected). Bun is used from packageManager/bun.lock.
4. No environment variables are required.
5. Deploy.

From the CLI instead:

cd apps/web
npx vercel --prod

cd packages/cli
npm login
npm publish --access public   # package name: goltui

Then users can run npx goltui add <component>.

Some components are adapted from open-source work and carry their own credit requirements. Please preserve these credits:

• Skiper UI — mouse-follow (simple & spring variants), text-scroll (credit required).
• Aceternity UI — plane-window-hero (WebGL cloud shader substituted with a canvas drift).
• Libraries.dev (MIT) — voice-glow, border-beam, thinking-orbs.

1. Fork the repo and create a branch: git checkout -b feat/my-component.

2. Follow Adding a Component.

3. Make sure it is clean before opening a PR:

   bun run lint
   bun run build

4. Open a pull request describing the component and any dependencies it adds.

MIT © goltUI