LixBlogs: an open-source collaborative publishing platform built with the Next.js App Router

[Circuit-Overtime]

I have been building LixBlogs, an open-source writing and publishing platform using the Next.js App Router. The repository is elixpo/blogs.elixpo.

It goes beyond a static blog engine: writers can collaborate in real time, publish through the web UI, CLI, or scoped API, organize stories into publications and collections, and run community writing contests.

A few Next.js implementation choices that may be useful to others:

• a dynamic catch-all reader route server-renders canonical metadata, Open Graph data, and BlogPosting/ProfilePage/Organization JSON-LD
• private, secret, draft, and unlisted states have distinct discovery rules instead of sharing one generic page response
• the initial home feed is produced through the same ranked feed path as the client, avoiding a second hydration fetch that used to reorder cards after first paint
• editor-heavy code remains behind client boundaries while public article HTML stays crawlable without client interaction
• Edge-compatible route handlers connect the App Router to D1, KV, media storage, and collaborative WebSockets

The project also ships reusable editor and CLI packages, so the same publication model can be used interactively or from automation.

I would appreciate feedback on the App Router boundaries, public-page rendering strategy, and places where the implementation could become a useful reference for other content platforms. Contributors and writers are welcome to try it.

[HIRATRA]

This is a really interesting architecture, especially the decision to keep the public article HTML server-rendered while isolating the editor behind client boundaries.

One thing I'd be curious about is how you handle the boundary between the canonical reader route and the different visibility states.

Since private, secret, draft, and unlisted content have different discovery rules, I would be careful not to let those rules live only at the rendering level. Having a single server-side authorization/discovery layer that determines whether a document is even eligible for the reader route could make it harder to accidentally expose metadata or JSON-LD for content that shouldn't be discoverable.

I also like the approach of using the same ranked feed path for the initial server render and the client. That seems like a good way to avoid the common "SSR shows one order, hydration fetch shows another" problem.

One question I'd have: how are you keeping the feed deterministic between the server render and the subsequent client updates? If ranking depends on mutable data, a cursor/version or snapshot identifier could be useful so the client knows exactly which feed state it is continuing from rather than recomputing the ranking independently.

Overall, I think the App Router boundaries you've chosen make sense. The public-content/client-editor separation in particular feels like a pattern that could be useful beyond blogging platforms.