r/Nuxt • u/Accomplished-Emu8030 • 36m ago
r/Nuxt • u/HumanOnlyWeb • 1d ago
Daniel Roe
Nothing *meaningful to share, but has anyone been looking at the merged PRs to Nuxt lately?
Daniel has been killing it with a lot of perf related fixes, changes and improvements; sometimes upstream in Vue, Nitro, then ports to Nitro v2, then finally to Nuxt.
Nuxt 5 will truly be great, perf-wise; I'm running a smaller app on it right now.
Shout out to you sir, we don't deserve you 🙌
r/Nuxt • u/decebaldecebal • 2d ago
I open-sourced my Nuxt 4 SaaS boilerplate after it made 2 sales
My first sale of NuxtBeyond came from a post in this sub earlier this year. It sold for $59 and made 2 sales in total. After seeing how the industry has evolved, I decided to make the repo public under MIT.
I think boilerplates don't sell much anymore, now that agents can scaffold a starter in minutes. I'd rather have people use it than let it sit there.
What's in it:
- AI chat with RAG over your own docs (Cloudflare AI Search), plus an embeddable chat widget you add with one script tag
- Google and email/password login with nuxt-auth-utils, email verification and password reset
- Stripe or Polar billing, switched with one env var
- Multi-tenant projects with admin/member roles and team invites
- Image generation (OpenAI) and video generation (Gemini), both optional
- NuxtHub on Cloudflare (D1 with Drizzle, R2, KV), Nuxt UI v4, deploys to Workers
Before making it public I had to fix some stuff I ignored after I stopped working on it. The video demo still used Sora, which OpenAI shut down in September, so it's on Gemini Omni Flash now. Images were on gpt-image-1.5, which goes away in December. I also ran gitleaks over the whole git history to make sure I never committed a key (luckily I didn't😅).
To be upfront, I'm not sure I'll be adding new features to it anymore. My own products still start from it, but treat it as a starting point you own, not something that gets regular updates.
Repo: https://github.com/BeyondFolder/nuxt-beyond
Demo: https://nuxtbeyond.com
Curious what you'd remove first if you started a SaaS from it. I know that the widget/RAG part isn't that popular or included in other boilerplates, but it took me a while to get that properly working, so it's available for whoever needs such a setup.
r/Nuxt • u/Denis_Lipatov • 2d ago
KateCMS, a content admin that lives inside your Nuxt app
I have been building KateCMS, a Nuxt module that adds an admin to the same app as the site. Collections, dictionaries, media, and roles are configured in `nuxt.config.ts`. The public site reads that content through composables. It is MIT, on npm as `katecms`, currently `1.0.0-beta.4`. There is no hosted demo yet, so the screenshots below are the admin itself.

The admin is a normal Nuxt route, `/admin` by default. The first account becomes the owner. After that you edit entries in collections, terms in dictionaries, and files in the media library. SQLite is the default (`data/katecms.db`), so a Postgres instance is not required to try it. Postgres 15+ is there when you want it.
Fields are declared next to the collection: text, WYSIWYG, repeaters, flexible blocks, galleries, relations, maps, and the usual form controls. The same config is what the site queries.


On the site, `getCollection`, `getTerms`, `getOptions`, and `getQueryCollection` return that content. A minimal setup is:
export default defineNuxtConfig({
modules: ['katecms'],
})
npm install katecms
One Nuxt 4 note: `app/app.vue` has to render `<NuxtPage />`. The module registers its pages with `extendPages`, and `<NuxtWelcome />` left in `app.vue` will sit on top of `/admin`.
Docs and the field reference are in the repo README: https://github.com/katecms/katecms
I would like to hear what is missing for a real project, especially around the content API and the admin. Issues and rough edges are welcome.
r/Nuxt • u/Calm-Koala-6244 • 5d ago
I made a VS Code extension to preview Vue components in Nuxt/Vite projects
Sharing this from the Vue community since it is specifically made for Nuxt projects.
I couldn't find a good way to preview Vue components in isolation in a Nuxt project, so I made a VS Code Extension that supports Nuxt, SSR, Server Islands, and works reasonably well with routes and middleware: https://marketplace.visualstudio.com/items?itemName=timeful.timeful-studio-vscode
r/Nuxt • u/Atlantik15 • 5d ago
I made a free CLI that scans your Nuxt 3 app for Nuxt 4 breaking changes
Since Nuxt 3 hit end of life at the end of July, I've been going through the 3 → 4 upgrade guide a lot, so I turned the checklist into a small CLI:
npx nuxt4-check
It's zero-dependency and read-only, and nothing leaves your machine. It flags the things that actually bite in practice: null checks on useFetch/useAsyncData data (they're undefined now), nested mutations on data (it's a shallowRef now), boolean dedupe, window.__NUXT__, route.meta.name, top-level generate, hid/vmid head props, KeepAlive name lists and so on. It also lists your modules to verify, gives a rough effort estimate, and can write a Markdown report (--md) for your ticket.
It's heuristic, so I'd love reports of false positives or misses. Repo: https://github.com/atlantikjashari/nuxt4-check
r/Nuxt • u/MaintenanceOld2216 • 6d ago
Just updated your favorite Vue and Nuxt component library
Mood UI Documentation
Mood UI on NPM
Mood UI Repo
Hey guys, just pushed an update to Mood UI with a bunch of new animated components (press buttons, morph tooltips, morph select, glass switches, surface cards, new dialog, drawer and a menu), all of them follow the provider so colors, radius and dark mode just work everywhere
also been working on something bigger for a while, its called "Mood Kit", its a SaaS starter kit built with Mood UI, Nuxt 4, Laravel 13 and Postgres, basically the base i always end up rebuilding for every project
whats already in:
multi tenant with a subdomain per workspace, data isolated with postgres row level security (not just a where tenant_id lol)
auth, signup with email verification, roles and permissions with a visual editor, audit log
workspace settings and white label branding (logo, colors, radius, language, currency)
plans, quotas, free trials and stripe subscriptions (upgrades, downgrades, customer portal)
emails with editable templates, in app notifications in realtime, daily digest, one click unsubscribe
onboarding, team invitations, branches with a map picker
a super admin panel on its own subdomain where you can manage every workspace, plans, access mode/waitlist and log in as any user to help them
whats coming:
branch switcher, customers with a portal, smart search, dashboard with widgets
a module system so you can add your own stuff with the same structure
stripe connect (optional) so your customers can get paid trough your platform
docker images for prod and full docs
later some extra modules like booking, catalog, pos and a mobile app
one thing im really trying to get right is making it AI friendly, the kit comes with an AGENTS.md with all the guidelines, conventions and rules of the project, so if you use claude, cursor or whatever, the agent builds new stuff the same way the rest is built and everything stays consistent instead of turning into a mess after a few features
everything is tested and every module gets a security review before its merged, ill share more when its closer to launch, would love to hear what you think or what you would want in something like this
r/Nuxt • u/drifterpreneurs • 8d ago
Why doesn’t Nuxt receive the attention it deserves?
Hi fellow devs,
I’m just wondering why Nuxt doesn’t receive enough attention? I have been a full-stack dev for a few years now, but I never really enjoyed full-stack frameworks until I found Nuxt. Nuxt is simplicity on steroids as it allows you to work extremely fast.
Can’t say I ever felt a chokehold while working with it. I enjoy the freedom of building how I did in express without the pressure of framework conventions and Nuxt definitely felt more natural to me.
What’s your experience with Nuxt?
r/Nuxt • u/murisceman • 8d ago
Pruvious v4 lives on as "ohne"
Hi Nuxters! Some of you know Pruvious, the CMS for Nuxt. Version 4 was a rewrite from scratch, with a new dashboard, live page editing and a better ORM. It got as far as an alpha (npm create pruvious@alpha), but it never reached a stable release.
Instead, it grew into ohne (https://ohne.dev) (German for "without"). It's a TypeScript framework with zero dependencies and no build step. Node 26+ runs your .ts files directly. A lot of v4 lives on in it, including the entire dashboard.
Pruvious used to live inside your Nuxt app. ohne runs as its own app beside it (monorepo). ohne is the backend and CMS, and Nuxt is the website.
@ohnejs/nuxt - Nuxt module that renders CMS pages.
Starter monorepo:
npm create ohne@latest my-site --web nuxtTutorial: https://ohne.dev/tutorials/rayleigh/nuxt
It's still early (0.8) and MIT licensed. I'd really like your feedback, especially if you used Pruvious. Cheers! :)
r/Nuxt • u/navid-jaberi • 13d ago
I made a Nuxt module that turns your real components into their own skeleton (SSR-rendered)
I got tired of building a second, hand-made skeleton for every component, so I wrote a v-skeleton directive, and now there’s a Nuxt module for it:
npx nuxi module add nuxt-smart-loading-kitNo plugin file, no CSS import. Then:
<script setup lang="ts">
const { data: user, status } = await useFetch('/api/user', { lazy: true })
</script>
<template>
<UserCard v-skeleton="status === 'pending'" :user="user ?? placeholderUser" />
</template>While loading, text becomes bars, images and buttons become blocks, and borders and spacing stay. It’s CSS only: no measuring, no DOM changes, so nothing shifts.
What the module does for Nuxt specifically:
The directive renders on the server, so a loading card is already a skeleton in the first HTML. No flash of empty content before hydration.
Auto-imports
<Skeleton>,<Spinner>,<SmartLoader>,<ProgressBar>and<PageProgress>. A page only ships the ones it uses.<PageProgress>follows navigation like<NuxtLoadingIndicator>, but you can also drive it for your own tasks withusePageProgress()(e.g. around a$fetchPOST).prefixoption if another UI library already has a<Skeleton>.Works with Nuxt 3 and 4.
Live demo: https://navidjaberi.github.io/vue-smart-loading-kit/
GitHub: https://github.com/navidjaberi/vue-smart-loading-kit
Known limits: the last line of a wrapped paragraph gets a full-width bar, and it needs browsers from late 2023 (:has, lh, mask-composite).
It’s a fresh module (0.1.0), so I’d really like feedback, especially from people using it alongside Nuxt UI or Vuetify. How do you handle loading states in Nuxt today?
r/Nuxt • u/depressedpenguyn • 14d ago
GoopUI update, dropdowns dialogs and new docs site in process
r/Nuxt • u/quasarui • 14d ago
Where things go in a Nuxt 4 project: app/, server/, shared/ and public/ (with a Quasar setup as the example)
Here is the cheat sheet I use for what goes where in the Nuxt 4 layout. Sharing it in case it saves someone the same back-and-forth.
my-app/
├─ app/ # srcDir: everything the browser bundle uses
│ ├─ assets/ # Sass, fonts; quasar.variables.scss lives here
│ ├─ components/
│ ├─ composables/ # auto-imported
│ ├─ layouts/
│ ├─ middleware/ # route middleware
│ ├─ pages/
│ ├─ plugins/ # what a Quasar CLI app would call boot files
│ ├─ utils/ # auto-imported
│ ├─ app.vue
│ └─ error.vue
├─ server/ # Nitro: never shipped to the browser
│ ├─ api/ # /api/* handlers
│ ├─ routes/ # handlers without the /api prefix (sitemap.xml.ts)
│ ├─ middleware/
│ └─ utils/ # auto-imported on the server
├─ shared/ # code both sides import
│ ├─ types/
│ └─ utils/ # auto-imported in app/ and server/
├─ public/ # served as-is from /
└─ nuxt.config.tsThree rules that settled most of my "where does this go" questions:
If the server must never see it, it's in app/. If the browser must never see it, it's in server/. Secrets, DB clients and anything reading private runtime config stay in server/.
shared/ is for pure code only. Types, constants, validation, formatters. No Vue imports, no Nitro imports, otherwise one side breaks.
~now means app/. SosassVariables: '~/assets/quasar.variables.scss'in the Quasar module config points toapp/assets/, not the project root.
Anything you put somewhere different? I'm curious how people split shared/ in bigger apps.
r/Nuxt • u/-Philologian • 15d ago
best CMS to use with Nuxt?
Curious everyones thoughts on this. I tend to use Sanity with my Next builds but want to use Nuxt more. I know you can use Sanity with Nuxt but it doesn't seem as seamless if I'm understanding the docs.
I wrote a Nitro preset to run Nuxt SSR on EU-only infrastructure (beta)
I run deploybase, a small European host for static sites. Until this month Nuxt only worked there as nuxi generate. So I wrote a Nitro preset, and Nuxt 4 apps can now render on demand, with everything in the EU (servers in Paris, CDN by Bunny in Slovenia).
How it works:
nuxt buildwrites.deploybase/v1/: astatic/folder for the CDN, aserver/folder with the Nitro server and a smallconfig.jsona file that exists in
static/is always served from the CDN and never wakes the serverevery other request goes to your Nitro server, running as a function (Node 22) that scales to zero
a missing
/_nuxt/chunk goes to your server too and gets your app's 404, sentno-store, so an old chunk name can't get stuck in a cache
What doesn't work (yet), because I'd rather you read it here than find out after deploying:
useStorage()andswr/cacheroute rules live in memory per instance, gone when it scales downno
scheduledTasksand no WebSockets (SSE and streaming work)server responses are never cached at the edge, so prerender whatever you can
cold starts take a few seconds after the server goes quiet
Nitro 2 only. I haven't started on Nitro 3
Setup is npm install @deploybase/nitro-preset and nitro: { preset: '@deploybase/nitro-preset' }. The preset is open source: codeberg.org/deploybase/deploybase-adapters (packages/nitro-preset). The full guide, including the differences above, is at docs.deploybase.eu/guides/nuxt
To be upfront about money: server routes need a paid plan (Starter is €9 a month). On Free, the static path with nuxi generate works and the prerendered pages of an SSR build still go live.
If you run Nuxt SSR, I'd love to know which feature matters most to you, so I know what to work on next.
r/Nuxt • u/dazoro-alex • 16d ago
How the LCP gate actually opens in my Nuxt app
On my own Nuxt + headless WordPress site, Dazoro, secondary CSS, link prefetch and 3D share a readiness signal. Here is how the code decides to release that work.
The browser supplies the paint candidate. In onNuxtReady(), a PerformanceObserver subscribes to largest-contentful-paint with buffered: true. Buffered entries let initialization recover earlier paint reports. Each entry supplies a timestamp and, when exposed, the DOM element.
The application supplies the release rule. This is the LCP branch, simplified from the implementation; initialization, other triggers and cleanup are described below:
function handleLcpEntries(entries) {
for (const entry of entries) {
if (finalized) break
if (entry.entryType !== 'largest-contentful-paint') continue
lastLcpEntry = entry
lastLcpTime.value = entry.startTime
const el = target?.value
if (el && strictTarget) {
if (entry.element === el) finalize('lcp-strict')
} else {
clearTimeout(arm)
arm = setTimeout(() => finalize('lcp-general-soft'), 50)
}
}
}
lcpObserver = new PerformanceObserver(list =>
handleLcpEntries(list.getEntries())
)
lcpObserver.observe({ type: 'largest-contentful-paint', buffered: true })With a valid strict target, a different element does not release work through this branch. A matching candidate does. Without an active strict target, each candidate resets a 50 ms timer: the general branch releases work after that window without another processed candidate.
For example, an initial text candidate followed by a hero-image candidate resets the general timer. In strict mode targeting that image, the text candidate cannot open this branch. This illustrates the algorithm, not a measured trace.
Finalization connects detection to loading. finalize(reason) runs once, preserves the recorded timestamp, disconnects observers and releases listeners/watchers. With the default zero postLcpDelay, it sets shared isLcpReady immediately. Secondary stylesheet insertion and the 3D loader import can then proceed; 3D keeps its device/visibility conditions. Default link prefetch has a separate flag, normally enabled 300 ms from finalization. Critical first-screen CSS still arrives through SSR.
Other release paths are explicit. Optional Element Timing can finalize on an entry marked lcp-candidate; this identifies the reported marked element, not its status as the page’s largest content. Interaction, load, a 7500 ms timeout and lifecycle/error fallbacks can also release the gate. They are escape paths when waiting is no longer useful, rather than measurements proving final LCP.
Late initialization needed special handling: if readyState === 'complete', the code processes queued LCP/Element Timing records through takeRecords() before using the load fallback. Otherwise it could miss the already-fired load event. Six retained regression cases cover late-load and fallback behavior.
In manual comparisons under different CPU/network throttling, my recorded LCP time and DevTools’ Performance-panel value differed by only a few milliseconds. That checks the timestamp being read. An observer callback runs later, and its delivery or the gate’s release latency requires a separate timestamp.
The browser can report later candidates, so target matching and the 50 ms window do not certify final LCP. This gate is an explicit application decision for the initial client app session; it stays open across SPA transitions.
How do you choose that release rule when a page’s largest element can change during loading?
r/Nuxt • u/dadashi44 • 17d ago
vue-why-render 0.8 — see why your Vue components re-render. Now with reactivity graph, DevTools deps inspector, and VS Code extension.
Hey r/Nuxt ,
I've been building **vue-why-render** — a dev tool that tells you exactly which reactive dependency triggered each re-render. React has `why-did-you-render`, but Vue had nothing like it. Now it does — and it's faster, powered by Rust/WASM.
Drop it into any Vue 3 app:
```ts
import { scan } from 'vue-why-render'
scan(app, { panel: true })
```
You get:
- **Overlay labels** on every component that re-renders — name, count, duration, and the exact reason (`prop badge: {text} → {text} — new reference, same value`)
- **Actionable hints** — "this object is rebuilt in the parent — hoist it into a constant or a computed"
- **Panel** with 5 tabs: Top (by renders), Slow (by duration), Tree (hierarchy with Σ sums), Events (chronological log), and the new **Deps** tab
- **Prop diffing** — shows old → new value and flags "new reference, same value" vs real changes
### What's new in 0.8
**Reactivity Graph (Deps tab)** — tracks `renderTracked`/`renderTriggered` to build a live map of component → reactive source. Two views: Components (which refs/props/stores does this component read?) and Sources (which components depend on this ref?). Filterable, with read/trigger counts per edge.
**Vue DevTools Integration** — a second inspector with a reactive source tree (colored tags by type: ref, prop, store, computed), and a second timeline layer that logs every dependency trigger as an event.
**VS Code Extension** — WebSocket bridge streams live data to VS Code. You get: component tree sidebar (sorted by renders, flame icons for hot components), deps tree, CodeLens annotations on `.vue` files showing render count + avg duration, status bar with live counter, and pause/resume/reset commands.
### Performance
Heavy lifting runs in Rust/WASM — tree building, deduplication, report diffing. JS fallback kicks in automatically where WASM isn't available (SSR, jsdom, strict CSP). The overlay and panel live in a shadow DOM so they never touch your app's styles.
### Also built in
- Pinia-aware: names the store, the field, and the action (`store cart.items: Array(1) → Array(0) · action clear()`)
- Vue Router-aware: names the route param that changed, not the whole route object
- Budgets: `maxRenders` per time window, `maxDuration` per update — violations in console + panel + reports
- Reports: JSON export, Markdown for GitHub issues, diff two reports to catch regressions
- Test utils: `expectRenders(ProductCard).toBe(0, action)` — the fix stays fixed
- Nuxt module: `modules: ['vue-why-render/nuxt']`
- i18n: EN, RU, ZH
### Links
- **Live demo**: https://dadashi44.github.io/vue-why-render/
- **GitHub**: https://github.com/dadashi44/vue-why-render
- **npm**: `npm i vue-why-render`
- Zero runtime dependencies. MIT.
---
Would love to hear feedback. If you hit a bug or want a feature, issues are open.
r/Nuxt • u/mkishere • 17d ago
NuxtHub or Void?
I am working on a new project which was developed around NuxtHub for CF R2, KV and D1 access. Heard that Void is out and advertise it would simplifies things with CF. Should I migrate the codebase to Void in the middle of development? TIA
r/Nuxt • u/phenxdesign • 17d ago
Piwi: Playwright dashboard with Nitro/Nuxt integration: backend logs and coverage next to failing tests
Playwright's HTML report is great for one run, but it dies with the CI artifact.
Piwi is a self-hosted dashboard that keeps every run, trace, and attachment. The dashboard itself is built with Nuxt 4.6, and it ships a Nitro/Nuxt plugin that attaches backend logs and server-side coverage to the exact request that made a test fail.
I'm the author and built it in my free time, not a company product.

Backend logs
The @ /piwitests/instrumentation NPM plugin captures Warning/Error entries from consola per HTTP request and delivers them via the X-Piwi-Logs response header. The reporter stores them next to the network request. In the dashboard, they show up inline in the Network tab of the failing execution. Active outside production by default, controlled by PIWI_TEST_LOGS_DISABLED.
Code coverage (front and backend)
With a backend instrumented for coverage, each test records which files, functions, and lines ran server-side. The reporter reads it from X-Piwi-Coverage and keeps it per test, even against a shared parallel backend. Unit-test coverage (Cobertura/LCOV) can be uploaded and combined with Playwright coverage, commit by commit. All this is combined with front-end coverage (JS and CSS) thanks to the Chrome coverage feature, wired with Piwi.
See an example in the interactive demo (in the browser, see below) : https://piwitests.dev/demo/projects/5/coverage
Learn more in the docs:
Backend logs: https://piwitests.dev/guide/backend-logs.html
Coverage: https://piwitests.dev/features/combined-coverage.html
A similar integration is also available for Aspnet Core.

Where it runs
The main app is installable as a Docker container, but also a Tauri-embedded desktop app for local test runs (learn more)
There is also a companion browser extension for Chrome and Firefox that will help you choose the best locators, and when connected to a Piwi instance see what page elements are tested or not in your tests, record scenarios, record bug reports as scenarions, etc.
I also made an IDE plugins for JetBrains and VS Code that let you highlight your failing tests, and show code coverage, directly in your code.
You can try the live demo with seeded data on https://piwitests.dev/demo/ if you want to see the UI without installing anything.
It is completely static, hosted on Github pages, with a service worker to intercept all the HTTP requests, you can learn more in the blog post I made a few months ago : https://piwitests.dev/blog/how-piwi-was-built.html
GitHub : https://github.com/PiwiTests/piwi
Website : https://piwitests.dev/
Demo : https://piwitests.dev/demo/
r/Nuxt • u/depressedpenguyn • 18d ago
Working on an open-source goopy ui framework... Shadcn, but it drips
Oxynote, an open source workspace for your internal docs and metrics (built with nuxt 4)
Hey r/Nuxt
For the past year my friend David and I (Simon) have been building Oxynote, an open source wiki you host yourself, where a Notion-like page holds live observability charts next to the text that explains them. So instead of the docs living in Notion and the charts in Grafana/Datadog, a page about one of your services can show things like its error rate right above the steps to fix it. The charts run real Prometheus and SQL queries, several people can edit a page at once, and important pages change through a draft->main merging/review process, like a pull request.
David discussed how the backend works in r/golang, so I thought I would present how we use nuxt to render and serve our UI. (A bit about me: I've been a software engineer for 10 years, 4 of them with vue and nuxt (bless both of them), and contributed to a bunch of open source projects, and David and I maintain ttlcache, a fairly popular caching library for Go.)
So here are some interesting details about Oxynote's frontend/nuxt setup:
We use Tiptap 3 on Yjs, synced through Hocuspocus, for real-time editing
ECharts via vue-echarts is used for the charts, CodeMirror 6 for the PromQL and SQL editor (we've forked and written some adapters to allow the editor to perform complex autocompletions and code suggestions)
Pinia Colada is used for data fetching
We integrate shadcn-vue with some custom modifications. For styling we also use Tailwind v4
The same nuxt codebase also builds an internal, experimental Electron app (not released yet). A Vite define,
__DESKTOP_BUILD__, picks SSR or a static SPA at build time, and on desktop the session stays in Electron's main process.We don't use nuxt's Nitro server routes. For now, Nuxt is used only for the UI: it renders pages and calls the backend with
$fetch. The backend is a Go API and a Node service of its own, because:it serves more than this app. MCP clients like Claude Code, GitHub and Slack webhooks, and the desktop build all call the same APIs
the heavy work is long-running, which suits a Go service more than request-scoped handlers: queries against your databases with credentials encrypted in Go, a search index, durable background jobs and the AI assistant
real-time editing needs a long-lived Node process, where Hocuspocus keeps documents and websockets open and Better Auth owns the sessions
It's a fun project to work on but at the same time I believe it solves a big problem that no Grafana/Datadog+Notion combo can solve. If you have any feedback, ideas, or want to try it out and need help setting this up, shoot me a message or a comment below. This is free, fully open source (under Apache-2.0) and ships as one Docker image.
More info in our repo here: https://github.com/oxynote/oxynote
r/Nuxt • u/Smart_Opportunity291 • 19d ago
I made a Nuxt Agentic module to add agents, tools, and automations to Nuxt
r/Nuxt • u/Material-Tie-5044 • 21d ago
I built a silly Greek folk-magic site with Nuxt 4. Share links carry the result, so there is no database
Side project: https://ftouftou.com/en
A made-up Greek grandma, Kyra Ourania, removes your evil eye with olive oil and water, reads your coffee cup and pulls tarot cards. It's free and there's no sign-up.
Some Nuxt bits that might be useful to someone:
Nuxt 4 with Tailwind 4 and @nuxtjs/i18n (Greek by default, English under /en), in Docker on a small Hetzner server.
Nothing the user types leaves the browser. The server keeps three counters and that's it.
Share links carry the result itself. The cards, coffee symbols and their positions are packed into a few bytes and base64url-encoded in the path, like https://ftouftou.com/en/t/AQMHAQ. The page is rendered on the server from that code, so a friend sees the same reading and I have nothing to store or delete. I had to exempt those paths from a middleware that lowercases URLs for SEO, because it was breaking the codes.
The Instagram story image is drawn on a canvas as soon as the result appears, not when you tap share. Safari can refuse navigator.share if there's async work between the tap and the call.
Analytics with self-hosted Umami, no cookies.
Questions welcome, and I'd like to hear what you'd do differently.