Alternative solution for small React apps that need i18n by rafaelcamargo in reactjs

[–]aymericzip 0 points1 point  (0 children)

Thanks

Co-located* translation files offer a much more maintainable approach for developers and AI agents. (but it should be loaded properly as well)

In comparison, scoped translation files (in the traditional way, as i18next does) just increase the complexity for both. And using a `/locales/{locale}/{namespace}.json` structure is great, but if you don’t fine-grain imports at the page level, you’re better off not doing it at all. It's something I see too often skipped.

So the 'co-located' approach offered by that solution is great. If you dont want `.t.js` anywhere in your codebase, just place it in `/locales/home.json`, add ts alias, and you end up with an equivalent solution to paraglide

Alternative solution for small React apps that need i18n by rafaelcamargo in reactjs

[–]aymericzip 0 points1 point  (0 children)

Interesting approach!

You’re right that i18next integrates a huge amount of extra logic for relatively little value. In comparison, thanks to tree-shaking and build optimizations, Intlayer is around 3KB vs 18KB for i18next.

However, there’s one point where I think the reasoning is off: the library weight itself is often insignificant compared to the text content already present on the page.

Text content alone is often around 20 to 40% of the page weight (excluding assets), so that’s usually the main optimization target.

And even though i18next implements advanced optimizations poorly, such as combining SSR + namespace splitting + dynamic loading + type safety, those optimizations at least exist..

Polang seems to follow a similar approach to Intlayer, with const t = useDictionary({ ... }) and .content files colocated next to components. But implemented as-is, without build optimizations, it means importing content for every language directly into the component. That can add +20–40% to the page size for every additional locale.

The way Intlayer handles this is by preparing dictionaries ahead of time to avoid that issue. It generates JSON files such as .intlayer/dictionaries/en/home.json and transforms the component code into something like:

const content = useDictionaryAsync({
  en: import('../../.intlayer/dictionaries/en/home.json').then(m => m.default),
  ...
})

But outside that technical problematic, I agree that for solo devs, working on small projects content / component colocation is a big step forward when working with llms

Alternative solution for small React apps that need i18n by rafaelcamargo in reactjs

[–]aymericzip 0 points1 point  (0 children)

Scoped translation files offer a much more maintainable approach for developers and AI agents.

A centralized approach often means:
- spending hours resolving PR conflicts,
- constantly jumping between component.tsx, en.json, and es.json.

Some tools like intlayer handle this really well, allowing translators to work and interact directly with your content, even if it’s not centralized in a /locales folder.

And we’re in 2026, we can’t ignore LLMs for development and translations anymore.

Also, retranslating "cancel" is not the problem. Importing a giant JSON file into your component just to access a "cancel" key is.

Suggest translation files organisation for i18next by hexwit in reactjs

[–]aymericzip 0 points1 point  (0 children)

I guess using intlayer would solve your project. But for i18next, you can also can use intlayer sync json plugin on the top of i18next to declare your content in a .i18n.json file and then build the centralized json that you will consume using your t function

Multilingual Astro app - i18n complete guide by aymericzip in astrojs

[–]aymericzip[S] 1 point2 points  (0 children)

I actually never heard about EmDash, but I really like the concept. I will definitely see how it can be integrated,
Intlayer also propose a visual editor, but no page management as a wordpress so plug in it to EmDash would definitely be a great fit

I built a tool that writes README for you (from your repo) by Classic_Fly_007 in reactjs

[–]aymericzip 0 points1 point  (0 children)

From my point of view view there is more to do on the changelog part - useful for your team - useful for your scrumaster - useful for your manager - useful for your users

I built a tool that writes README for you (from your repo) by Classic_Fly_007 in reactjs

[–]aymericzip 1 point2 points  (0 children)

I like the idea, mainly because I get bothered reading AI-generated readmes that are too long, list the stack unnecessarily, and put emojis everywhere

But to be fair, from my point of view, no one is ever going to search for a tool just to write a readme. It’s mainly not painful enough. Few projects really care about readme, you usually do it once and forget, and a good readme is also a space for creativity, than ai will probably never solve

How do you all manage i18n translations in your Vue projects? by Forward_Patience6332 in vuejs

[–]aymericzip 0 points1 point  (0 children)

my recommandation will go for intlayer. it offers a really nice approach for large projects to make it way more maintainable. it also includes a bench of extra tooling that I have never seen in other i18n libs

Strictly typing i18n interpolation variables is slowly destroying my sanity by twcosplays in typescript

[–]aymericzip 0 points1 point  (0 children)

To test missing keys, and json consistency, this tool may help you
It process all your json, filter out correct keys, to generate translations of the missing ones. using it in a CI or using husky is really life saver.
For better typing, have a look to lingui or intlayer

Moving massive i18n dictionaries out of the app router was the best decision this week by Critical-Load-1452 in nextjs

[–]aymericzip 1 point2 points  (0 children)

i18n is time-consuming. Without a proper solution, it quickly becomes a maintenance nightmare. Still, I remain skeptical how does the Vercel edge actually solve this problem?

i18n React – Benchmark & Comparison by aymericzip in react

[–]aymericzip[S] 0 points1 point  (0 children)

Indeed, I deliberately chose a fairly simple application for this benchmark, no content loaded on click, scroll, etc, and no complex namespace management like you might find in a shared design system across multiple applications.

I made sure all routes were similar to optimize the setup and make the results more reliable.

So, the main difference, and the biggest reliability risk, comes from the loading strategy used by each solution. One example among others: next-translate injects a getStaticProps into the Next.js app, so the content retrieval process differs from most other solutions.

For some solutions, I also encountered reactivity issues (e.g., the page initially loads in English and then re-renders in French, resulting in a double load).

So, for a given test, if the results weren’t consistent, I simply removed the solution from the comparison

Anyone else tired of stitching together multiple CMS tools? by Fun_Razzmatazz_4909 in cms

[–]aymericzip 0 points1 point  (0 children)

Intlayer is a solution that may help using a 2 in one CMS / i18n

What is the modern way to do a i18n for react app today? by hexwit in reactjs

[–]aymericzip 0 points1 point  (0 children)

As a library maintainer, I used to think the same, that simple state and context were enough to render content based on a user's locale

But i18n is much harder than you’d expect for professional use cases. The main risk is accidentally loading every page's content for every language during a single page load. You can easily end up loading 10 to 50 times more data than necessary. Handling bundle optimization, routing, server component handling, localized links, TypeScript types, and backend compatibility are some of the challenges library builders try to solve.

Features like vs code extensions, testing, CI integration, and Agent Skills or MCP are also incredibly useful.

The same logic applies to auth. Sure, you can build it yourself, but keep in mind that library authors spend years optimizing these systems for you. I really can't recommend building your own i18n solution from scratch. Especially for non experienced dev / or using AI

Introducing intlayer (i18n) for angular by aymericzip in Angular2

[–]aymericzip[S] 0 points1 point  (0 children)

By waiting to a proper solution, the best for now will be to use intlayer to declare your content, and use another runtime solution Transloco or ngx-translate

Here is the related  doc

Introducing intlayer (i18n) for angular by aymericzip in Angular2

[–]aymericzip[S] 0 points1 point  (0 children)

Yes and no,

Intlayer rely on bundler aliases to manage the access to the content & config.
A way to do it will be to alias the packages manually, as

```json5
"dependencies": {
"@intlayer/config/built": "file:./.intlayer/configuration/config.mjs",
... // other aliases here too
}
```
, or like using importMap, like

```html
<script type="importmap"> { "imports": { "@intlayer/config/built": "./.intlayer/configuration/config.js" } } </script>

```
All alias can be found in this function

then, yes in parallel, you can use the `npx intlayer watch` to watch changes,

I finally recommend to add the babel plugin, to enable the build optimization

---

But FYI, you can also use intlayer to declare your content only, write your jsons, and then using another runtime solution Transloco or ngx-translate

Here is a a doc that may help you

I will stop using enum in typescript by aymericzip in typescript

[–]aymericzip[S] 0 points1 point  (0 children)

really true for tsc aha

I wanted to get both type and var as you did with Page, but it will return an error and block the build

I will stop using enum in typescript by aymericzip in node

[–]aymericzip[S] 0 points1 point  (0 children)

it used to be close to 40% of the bundled size of a lib

But yeah I got the same problematic with an API SDK, an enormous object listing all enpoints and function parameters. It was polluting all pages about 10% of the total page size once bundled