For builders of AI products

Give your software
a glım.

Your model already thinks. Your UI still shrugs with a spinner. Glim is a tiny library of living companions for the corner of an app — one four-state mind, forty-three bodies, drop-in and offline-ready.

glim

It listens, thinks, then answers. Move your cursor near it; it leans in.

Felt that? Next: configure yours and download a starter that works offline.

The gap

People trust a presence.
They ignore a loop.

If you build agents, copilots, or voice UIs, you already know the awkward pause: the model is working, the interface is dead. Lottie loops and pulsing dots say “loading.” They do not say “I’m with you.”

Why Glim

One mind. Any body.
Ship it this afternoon.

Glim helps AI product builders replace dead waiting states with a companion people can read — without a new framework, a 3D pipeline, or a design system rewrite.

Alive in the corner

Idle, thinking, talking, listening — plus proximity lean, idle stirs, and a “got it” pulse. Decoration becomes presence you can wire to real events.

Swap the body, keep the mind

Forty-three hand-built creatures share one API. Theme to your brand. Eight are free (MIT); the rest unlock when you are ready to ship the full menagerie.

Drop in today

Download an offline starter or glim.js, call mount(), wire say() to your model. No build step. No dependencies. Snippets for the stacks you already use.

Activate

Make it yours in under a minute.

Pick a free creature, copy a snippet, or download the offline starter. That download is the activation moment — your companion, running without this site.

glim
html js react next vue svelte angular web component swift kotlin flutter react native

    
Browse creatures

Activation = a file on your machine. Starter opens offline. Library file is glim.js; npm package is @axaylabs/glim.

The API

The whole surface fits on a postcard.

A body you can swap, a mind you can’t — seven methods total, and a couple of lines to ship. Grab the exact snippet for your stack from the configurator above.

mount(el, type, opts)

Give any element a soul. opts: size · theme · state · say.

setState(state)

Switch mood — idle · thinking · talking · listening.

say(text)

Type a real reply, then hold it.

react(power?)

A quick “got it” acknowledgment pulse.

setTheme(name)

Retint on the fly.

on(event, fn)

Listen for state and settle.

destroy()

Free the GPU context and remove it.

Glim.freeTypes

The eight MIT creatures you can ship today.

Pricing

Buy once. Ship forever.

Value metric: creatures you can put in front of users. Free is real (8 + API + downloads). Pro is the obvious ship choice. Checkout is on a waitlist — no fake buy buttons.

Free
$0 / forever

Ship a presence on a side project or first product today.

  • 8 MIT creatures
  • Full four-state API, themes, events
  • Offline starter + glim.js
  • Commercial use allowed
Get free starter

No account. No watermark.

Ship with this
Pro
$69 / one-time

For a solo builder putting Glim in a real product.

  • All 43 creatures
  • Unlimited personal & commercial projects
  • React & Vue wrappers
  • Live-AI streaming recipes
  • Lifetime updates within the major version

Leave an email — checkout when it’s live.

Team
$299 / one-time

One license for everyone at your company.

  • Everything in Pro
  • Unlimited developers at your company
  • Custom theme builder
  • Priority support

Same honest waitlist — no fake checkout.

Studio

Platforms, white-label, commissioned creatures.

Redistribution rights, brand-matched palettes, and a direct line to the maker. Priced for the work, not a price card.

Questions

Good to know.

Is the demo really talking to a model?

When this page has model access, it sends your message and types the real reply. In a normal browser it uses a local personality so the companion never looks broken — the status line under the demo tells you which mode you’re in. In your app, you wire say() to whatever model you use.

How heavy is it?

One self-contained file, no dependencies, no build step. A single shared render loop drives every creature, and only the ones near your viewport hold a live GPU context — the rest sleep and give theirs back. Idle creatures cost almost nothing, so a wall of forty-three stays smooth.

Does it work with React / Vue / Svelte?

The core is framework-agnostic — mount() takes any DOM element. The configurator writes snippets for the major web stacks today; Pro and Team include thin React and Vue wrappers so a companion is just a component.

Can I match my brand?

Every creature is themeable: pass a palette for the four states, or use a preset. The configurator above writes the theme code for you. Studio includes brand-matched palettes and commissioned creatures.

What do I actually get for free?

Eight core creatures, the full four-state API, theming, and events — MIT licensed. Download a self-contained starter HTML (opens offline) and/or glim.js. npm: @axaylabs/glim. No account, no watermark.

What about accessibility?

Companions are decorative by default and hidden from screen readers; captions are exposed as polite live regions when you use say(). Motion respects prefers-reduced-motion.

One conversion

Get a companion on your machine.

Talk to the demo, configure a free creature, download the starter or glim.js. That’s the whole funnel.

Before you go

Would you put this in your app?

Glim is early. The free starter is real; paid checkout is not live yet. One tap tells me whether to finish payments — or rethink the job. Leave an email only if you want a reply.

Maker kill criteria (binding): if after 50 honest feedback taps, fewer than 20% say “I’d use this,” stop polishing creatures and rethink the job-to-be-done. Signals stay on this device until you copy or email them.

glim