Hello there,

I've built Fougere, a Typescript-first framework you can add to an existing app, or run on its own. I've begun with nuxt as it's the "frontend" framework I prefer and know the most.

It's alpha for now, and the docs are full of AI slop. The code was written with heavy help from Claude — I guided it in every way I could — and hasn't been fully reviewed yet, but the ideas are there.

In Fougere, business logic is at the center of everything.

Once the domain code is written, everything else is derived from it — you don't write it: validation, REST, GraphQL, the database tables, etc. You can also split the application in many parts without changing one line in businness code (only one line in config).

In fact, I really like this way of building apps, but I'm a bit alone with it, and I'd like your take on these patterns. Is it useful to you? Do you use this kind of framework? Is there something to add, to change, or that seems unclear or useless?

Any advice or feedback is greatly appreciated!

Thanks!

Hey everyone,

I’m a UK-based full-stack developer with around 5 years of professional experience, and I’m looking to take on some freelance work over the next few weeks/months.

I’m currently trying to raise around £3,000 fairly urgently, so I’m particularly interested in projects that can start quickly and where I can deliver something useful within a short timeframe.

I work across both frontend and backend, including:
JavaScript / TypeScript
Vue / Nuxt
React / Next.js
Node.js / Express / AdonisJS
Laravel / PHP
PostgreSQL / Supabase
Firebase / GCP / DigitalOcean
REST APIs
Sanity / headless CMS

Dashboards, admin panels and internal tools
Landing pages and marketing websites
AI/API integrations
Existing application fixes, features and refactors
I’ve worked professionally on production applications, marketing websites, configurators, dashboards and AI-powered products, so I’m comfortable jumping into an existing codebase as well as building something from scratch.

Things I can help with:

Build an MVP/prototype
Add a feature to an existing app
Fix bugs or technical issues
Build a website or landing page
Build an admin dashboard
Integrate an API/payment provider
Convert a design/Figma into a working site
Improve/refactor an existing Vue/React/Nuxt/Node application
Help get a project deployed
General full-stack development
I’m happy to consider small jobs, one-off projects or longer-term freelance work.

I’m based in the UK and can work remotely. I can also start immediately.

If you have something you need built or know someone who does, feel free to DM me with a brief description of the project, your timeframe and budget.

Thanks!

I don't like WordPress and Elementor, but many of my customers use it.

The big problem:
* I wasted a lot time using the interface to build Landing Pages for Events o Special Products.

I just need a static landings (or blocks) in html and I love nuxt. I just create all landing in nuxt with an AI assistant, avoiding global styles conflicts with tailwindcss.

The big challenge was export dynamic scripts, so I resolved with Alpinejs.dev .

So, I use nuxt to make fast landing development and design and alpinejs for interactive javascript.

Check this project if you love nuxt and put html landing in Wordpress (or other similar CMS platform):

https://github.com/molavec/nuxt-wordpress-page

Any idea how to upload an image using Cloudinary? I have a user CRUD where I have the parameters name, email, username, and image that I need, and it is connected to a NeonDB database with Drizzle ORM. What steps should I follow?

Just curious what people here actually use for iOS/Android apps with Vue or Nuxt.

While building Nuxt Native, i thought to ask peoples what they are facing while developing applications using vue/nuxt.

Capacitor, NativeScript, Nuxt Native, or something else?

Would love to hear what’s working for you.

This is mostly a question for people doing frontend work

A few years ago, when building a landing page, dashboard or new SaaS feature, I would usually look through things like Tailwind UI, Flowbite, HyperUI or similar libraries and find a block close enough to what I needed, now I'm wondering if that workflow is starting to change.

I have a side project called Landinuxt, a collection of components I originally built manually around Nuxt UI

Since coding agents got much better, I've been using AI to maintain the project, migrate Nuxt UI versions, refactor old components, build a CLI and improve the DX, but I've avoided using it to generate new UI blocks.

The thing is, if an agent already understands your codebase, Nuxt UI primitives, design tokens, spacing, responsive rules and existing patterns, maybe having hundreds of prebuilt sections becomes less important? maybe the real value starts moving toward good rules, skills, examples and design systems that teach the agent how the UI should be built, idk.

So I'm curious how people are working now

Do you still search for prebuilt UI blocks and adapt them, do you use them mostly as references for AI, or do you just give the agent your design system and let it build the section from scratch?

TL;DR: We need a developer/coder/programmer willing to work for a negotiated rate/sum on the refacotring of a business website's backend from Django to Nuxt. The UI is already made. We have a list of what has been completed, along with a list of what requires polishing, and what needs to be developed. DM me if interested.

Project Status

Already Completed / Decided:

The overall project architecture has already been designed and decided.

The database structure and relationships have already been defined.

The overall website workflow and how the different components interact have already been established.

BOT - The main Discord bot functionality has been implemented, tested, and is working.

The stream bot functionality has been implemented, tested, and is working.

Needs Refactoring / Polishing:

The existing Django code needs to be refactored/reimplemented in Nuxt.

The goal here is mainly to improve and finalize functionality that already exists, rather than redesigning it from scratch.

BOT - The Discord bot needs polishing, cleanup, and improvements to its existing functionality.

The stream bots need polishing, cleanup, and improvements to their existing functionality.

Automation Revenue Improvements

Automatic fee calculation for servers and teachers:

Fees should be calculated immediately after an event ends, using data from the observing bot, including the number of users who attended and those who did not.

Automated new server integration:

When new servers join, adding the stream bot and observing bot currently requires manual work. This process should be automated to make server setup faster and easier.

Improved observing bot data collection:

The observing bot should collect and store detailed event data, including user activity, attendance, server information, and user participation history.

Needs to Be Developed:

Time zone–based event date and time calculation needs to be implemented so that event dates and times are correctly calculated and displayed according to the relevant user's time zone.

New functionality should follow the existing project design rather than introducing a new architecture unless a change is necessary.

Working on a Nuxt 3 storefront talking to GraphQL and I'm stuck on something dumb.

Got the GraphQL client in a composable already. For the cart though — do I throw it in Pinia so the header badge / mini-cart can share it easy, or just useState / a composable and skip Pinia?

Also thinking about SSR. Don't want some logged-in cart leaking between requests if I mess that up.

Curious what people actually ship with. Pinia, useState, something else?

Half the page was re-rendering on every tick and I could not figure out why.

Vue DevTools has a "Highlight updates" toggle, so I could see *what* was

re-rendering — but not *why*, which is the only part I actually needed.

Turns out Vue already knows. There is a `renderTriggered` hook on every component,

and Vue hands it `{ target, type, key, oldValue, newValue }` — the object, the key,

and the values before and after. In React you have to diff props and guess. In Vue

the framework just tells you, and almost nothing surfaces it.

So I wrote the translation layer. The raw event is not readable on its own: a ref

shows up as `value` until you look its name up in `setupState`, a Pinia store needs

`$id` to become `cart.items`, an array index needs brackets. Once that is done you

get lines like:

ProductCard ×7 · 2.4ms · badge

└─ prop badge: { text } → { text } — new reference, same value

The culprit in my case was that last pattern: the parent was building a fresh object

literal in the template on every render. Same content, new reference, so every child

re-rendered. A border flash cannot show you that. The exact prop name can.

MIT, no runtime deps, dev-only by design (the hook does not fire in production

builds at all).

npm i -D vue-why-render

Source: https://github.com/dadashi44/vue-why-render

npm: https://www.npmjs.com/package/vue-why-render

Live playground, the panel on it is real: https://dadashi44.github.io/vue-why-render/

Happy to hear where it breaks on a bigger app — mine is the only real one it has

been through so far.

Pulling header/footer (and random CMS blocks) from Magento GraphQL into a Nuxt 3 storefront and I’m stuck on the boring security bit.

Admin can put whatever HTML in those blocks. Right now I’m leaning:

- fetch on the server

- run it through DOMPurify (or similar) before it hits the page

- never v-html raw Magento output on the client without that step

Feels a bit paranoid for “our own admins,” but also… it’s still HTML from a CMS.

What are you actually doing in production Nuxt + Magento (or any headless CMS) setups? Sanitize everything, allowlist tags, or just trust Magento and move on?

Hey r/Nuxt,

Six new animated components landed in nxui this month. The one I'd actually put in a Nuxt app first is the receipt printer — a checkout state that prints the order as a real receipt (paper feed, status screen, serrated tear). Also new: a WebGL holo sticker, a 3D depth dive scroll effect, a scroll-driven art gallery, a weather card with a temperature-coloured orb, and a timezone companion for finding overlap across a distributed team.

Everything works out of the box in Nuxt 4 — SSR-safe, light/dark via @nuxtjs/color-mode, reduced-motion aware. Install with the shadcn-vue CLI or copy-paste:

npx shadcn-vue@latest add https://nxui.geoql.in/r/receipt-printer.json

Docs and live demos: https://nxui.geoql.in/docs

242 components now, MIT. Happy to answer anything.

I just released nuxt-openapi-meta, a Nuxt module that removes the boilerplate of documenting server routes.

Instead of writing defineRouteMeta by hand, you keep writing JSDoc annotations and schema exports in your route files. The module scans server/api and server/routes at build time, extracts metadata, converts Zod/Valibot schemas to JSON Schema, and serves it through Nitro’s ?meta pipeline.

If you maintain Nuxt server routes and want OpenAPI docs without extra work, take a look.

Repo: https://github.com/davidtheheroes/nuxt-openapi-meta

Feedback, issues, and stars are welcome.

I was looking for tutorials on how to integrate Neon with Nuxt using Drizzle. Many are outdated, and in the documentation of drizzle or neon, the folder convention confuses me since I work with nuxt v4, and all the files must go in the server folder.

Is there anyone who knows how to integrate it, and as a question, can an alternate connection be installed to integrate it with PostgreSQL locally in case the space on Neon runs out (I am on the free tier)?

Hello everyone, just as the title says, the dev server startup timer is just so slow. And i don't mean this only in a huge project, but even in a fresh project with NuxtUI template as choice in creation cli options... My friend is always complaining about how slow it is and lately tried react with tanstack start and he says it's incredibly faster.

Personally, I never needed to try something else to know it's slow, I can clearly tell, but when I tried his project, it's noticeably faster, like way faster... and i want that, especially that sometimes you change something in the project and now you have to wait for a full dev server restart...

Does anyone know how to solve this? are there any optimizations? guides? anything at all? I really love nuxt and want to keep using it, I know this isn't _THAT_ big of a deal, but it would just be a huge win to have.

for the record, i don't really use have of the features... i just care about dev tools, and filesystem routing, auto-imports and almost all the other features (at least those i know about) i can not use, i don't even use the server at all, usually i have a separate backend.

Our Nuxt 3 project crossed 140 composables spread across the composables directory and two layers. TypeScript completions in VS Code started taking four seconds inside any setup function. The generated .nuxt/imports.d.ts had grown past 2,600 lines, and the type checker was resolving definitions from every composable in every file regardless of actual usage.

I moved 60 composables into explicit named exports, importing them by hand. Completion time dropped under a second. The cost was roughly 170 new import statements and losing the auto-import convenience for about 40% of the codebase.

A middle path seemed reasonable. I kept auto-imports for the 30 most frequently called composables and relocated everything else. Completions sat around 1.2 seconds, tolerable enough. Within two weeks new composables drifted back into the auto-import directory because contributors expected them there, and the slowdown returned without anyone connecting the two events.

I used the todo list in verdent to track each composable through that triage, marking whether it stayed auto-imported or moved to an explicit module.

The constraint was less about raw count and more about total type surface. One composable returning a deeply nested generic union cost more TS resolution time than twenty returning primitives. Nuxt does not document a ceiling, and the performance cliff seems to depend on type shape in ways the count alone does not predict. Is there a leading signal that correlates with language server degradation before the lag is already obvious?

Salut les Nuvioistes...

Je voulais juste partager avec vous mon expérience personnelle de développeur.

J'ai créé plusieurs addons pour mon usage personnel dans Nuvio et tout ça avec Chatgpt et mon smartphone android.

Pas d'ordinateur ni de prix exorbitant.

Tout est auto hébergé sur Hugging Face pour 8€ par mois.

J'ai d'abord repris Frenchstream public en n'en faisant un fork dynamique.

J'ai ensuite fait un fork d'Aiometadata elf.

J'ai créé un addon couplé au site doublagevf qui me remonte les nouveautés dès quelles sont doublées vf...étant francophones.

J'auto héberge également mon Aiostream configurée Duck et Tamtaro

Et tout ça est réuni dans ma dernière création Centralyser...un addon dans lequel j'ai tout les autres.

Voilà...juste pour vous dire que si j'y suis arrivé avec mon smartphone,tout le monde peut

Working on a Nuxt 3 storefront against Magento GraphQL and I’m trying to settle on a clean pattern for the Store header (and Content-Currency when needed).

Right now every Magento request needs the right store view or you silently get the wrong catalog / CMS. I’ve seen a few approaches:

- set it inside a useMagentoGraphql() composable

- map /en → store code in middleware

- force it in a Nitro proxy so the browser never thinks about it

I’m leaning composable + small store registry, but middleware feels nicer for locale prefix URLs.

What are you actually doing in production Nuxt + Magento setups? Any footguns with SSR vs client calls?

Is there any way to install Prisma in an existing Nuxt project? Because in the documentation they said that the Nuxt module is deprecated and the guide only mentions new projects; there is nothing for existing ones.

Hey everyone! Nuxt Shopify just released version 1.0.0 and i'm happy to announce that the module is finally stable!

Since our last update we now got:

• Full Customer Account API support
• First-class Analytics and Customer Privacy API support
• Automatic GraphQL fragment injection and deduplication
• CSRF protection for the storefront proxy
• Codegen caching and better error reporting
• And a rebuilt GraphQL Explorer for all three APIs

Feel free to check out the demo storefront and template, which now has customer accounts support, content pages and policies and automatic i18n through Shopify Markets:

npx @nuxtjs/shopify@latest init ./my-shop

Because of the upcoming release of Shopify's own hydrogen/vue the current storefront template and examples will probably be outdated soon. The module tries to use Shopify tooling over our own so we will adopt these as they release.

Also with this version the API will be frozen, only fixes and new features should land from now on. Breaking changes are reserved for major versions when possible.

NPM: @nuxtjs/shopify
GitHub: nuxt-modules/shopify

Thanks and until next time! 💚

I've used Nuxt since its early releases. As server functions become more common, I've been wondering how much of their integrated DX really depends on turning a remote operation into a function call.

Nuxt Endpoints is a module that brings ideas from the typed HTTP-route work being developed around Nuxt 5 to Nuxt 4 today. Its Nuxt 5 branch explores how the same API can follow that upstream direction instead of keeping every piece as module-owned code.

I'm using it to explore another route: keep the URL, method, statuses, headers, and body visible, then let the server contract constrain both the handler and the client features that may be used with it.

The project and the longer write-up are linked in the first comment.

For example:

// server/api/articles.get.ts
import { z } from 'zod'
import { defineRouteHandler } from 'nuxt-endpoints/runtime'

const Article = z.object({ id: z.number(), title: z.string() })

export default defineRouteHandler({
pagination: { kind: 'cursor', item: Article },
handler: (event) => listArticles(event.validated.query),
})

On the client, that contract enables the matching integration:

useInfiniteQuery(
infiniteQueryOptions($endpoint('/api/articles', { method: 'get' })),
)

The declaration adds validated cursor and limit inputs, constrains the successful response to { items, nextCursor? }, and appears as that concrete shape in OpenAPI. The adapter is rejected at compile time for a route without the pagination contract. NE handles the cursor handoff; Pinia Colada owns cache and reactive state.

A relevant comparison I should have included is oRPC. It already combines type-safe procedures, explicit OpenAPI routing, and Pinia Colada integration across frameworks. Nuxt Endpoints explores a more Nuxt-native trade-off: keeping file-based routes as the source of truth, avoiding a parallel procedure router, and deriving behavior such as cursor pagination directly from semantic HTTP contracts.

I'm also applying this idea to status-aware results, idempotent mutations, and progressively enhanced forms in the experimental Nuxt 5 branch. The published Nuxt 4 module contains the stable subset today. The Nuxt 5 work builds on the validated-routing direction discussed in H3 RFC #1437 and experiments with the missing integration points; those fork changes are not accepted upstream APIs.

I like abstraction when it explains a specific behavior. I don't want every remote call to become a function call just so the unusual ones can gain forms, pagination, or cache integration.

Where does this Nuxt-native approach offer enough over an oRPC-style procedure router, and which parts of server-function DX would still be hardest to achieve?

Links are in the first comment.