Back to Ideas
Social Platform

Ghar: Your Home on the Internet

April 10, 2026
15 min read
web-revivalno-codesocial-mediacreator-economyaisaaspersonal-website
Ghar: Your Home on the Internet

The Inspiration: Escaping the Algorithmic Box

Browsing the web in 2026 feels like visiting the same IKEA showroom over and over. Instagram is for photos. Twitter is for thoughts. YouTube is for videos. Medium is for blogs. Each platform owns one slice of who you are, and you have to scatter yourself across all of them. Your "online presence" is a fragmented mess of profiles that don't talk to each other, none of which actually feel like you.

This is what the dead internet theory gets at, not literally that bots run everything, but that the web feels dead because everything looks the same. Every Instagram profile is the same grid. Every Twitter profile is the same timeline. The containers are so rigid that individual expression got squeezed out entirely.

The web revival movement is the counter-reaction. People are nostalgic for GeoCities, MySpace, hand-coded personal pages, not because the tech was better, but because those spaces had personality. Your page was yours. It was messy and chaotic and alive.

But we can't go back to requiring everyone to learn HTML. That gatekept the expressive web to people who could code. The question is: can we make that level of expression accessible to everyone?

The Competitive Landscape

The space is fragmented. Everyone does one piece, nobody does all of it.

SpaceHey and Noplace nail nostalgia, customizable profiles, friend lists, vibes, but they're narrow in content types. SpaceHey requires CSS knowledge for real customization. Noplace is text-only.

Tumblr is arguably the closest existing thing. Multi-format posts, custom themes with full HTML/CSS access. But it's fundamentally a reverse-chronological blog, not a structured page with tabs and modules. You can't organize content into sections, it's all one stream.

Neocities and Nekoweb are the spiritual home of the web revival. 500k+ users building wild personal sites with total creative freedom. But they require hand-coding HTML/CSS/JS. The barrier to entry is the entire problem.

Carrd, Webflow, Framer are powerful no-code builders with zero social features. No following, no discovery, no community. They're tools, not platforms.

Linktree and Bento are customizable but shallow, you can arrange links, not build pages.

  • SpaceHey -- Customizable (CSS), basic content, requires code, social

  • Noplace -- Partial customization (colors), text only, no-code, social

  • Tumblr -- Customizable (themes), multi-format, mostly no-code, social

  • Neocities -- Total customization, total content freedom, requires code, minimal social

  • Carrd/Framer -- Customizable, limited content, no-code, no social

  • Ghar -- Customizable (modules), every content type, no-code, social

The gap: Neocities-level expression + Notion-level ease + an actual social graph. Nobody's doing all three.

The Core Concept

Ghar (घर: "home" in Hindi) is a social platform where your profile isn't a profile, it's a home. Your home. And you can make it whatever you want.

  • Want a photography tab? Add one. Call it "photos" or "visual diary" or "things I saw today."

  • Want to write long-form essays? Add a blog tab.

  • Want to post short thoughts? Add a feed tab.

  • Want to embed your YouTube videos, tweets, and LinkedIn posts? Paste the link.

  • Want to host your game? Embed it.

  • Want a 3D avatar that greets visitors? Go for it.

  • Want your ghar to look like a 90s GeoCities fever dream? Or a minimal brutalist portfolio? Or a cozy digital bedroom? Yours to decide.

The core primitive: modules + tabs + theming, all no-code.

Modules

Drag-and-drop content blocks:

  • Feed: short posts, like tweets

  • Gallery: photos, art, moodboards (grid, masonry, or carousel layout)

  • Blog: long-form rich text with inline embeds

  • Video: uploads or embedded from YouTube, Vimeo, etc.

  • Music: tracks, playlists, audio player with waveform, or Spotify/SoundCloud embeds

  • Games: embedded web games (HTML5/iframe)

  • 3D: interactive scenes, avatars, objects

  • Links: curated collections

  • Shop: digital/physical goods

  • Canvas: freeform space (stickers, images, text, drawings)

  • Embed: any URL from any platform, auto-rendered

Embeds as a First-Class Citizen

Most platforms silo your content. Ghar does the opposite, it's a hub that pulls in your presence from everywhere else.

Paste any URL and Ghar auto-detects and renders the rich embed. No iframe wrangling, no copy-pasting embed codes. YouTube videos, Twitter/X posts, Instagram photos, LinkedIn posts, Spotify tracks, SoundCloud players, CodePen demos, Figma files, GitHub repos, they all just work.

You don't have to abandon your existing platforms. Your YouTube channel, your tweets, your Spotify discography, curate it all in your ghar alongside content that lives natively on the platform. Your ghar becomes the single canonical place that represents all of you.

Embeds work in two ways:

  • Embed module: A dedicated block for a collection of embeds (e.g., a "Favorite Videos" tab that's all YouTube embeds)

  • Inline embeds: Paste a URL inside a blog post or feed item and it renders inline, like how Notion or Slack preview links

Tabs

Organize modules into named tabs. No defaults, you define the structure. A musician's ghar: Music / Visual / Journal / Shows. A game dev's: Games / Devlog / Art / About. Reorder, rename, add icons.

Theming

Not "pick an accent color", real control:

  • Full color palette (surfaces, text, accents, borders)

  • Font selection (curated set + custom upload)

  • Layout density, spacing, border radius

  • Animations and transitions

  • Background media (images, patterns, gradients, video)

  • Custom CSS escape hatch for power users

Technical Architecture

The core challenge: deliver a flexible, expressive page builder that feels instant to use, renders fast for visitors, and scales without the hosting costs of running arbitrary user code.

1. Page Schema: JSON Document Model

Each user's ghar is a JSON document, not a database row with fixed columns.

{
  "page_id": "usr_a1b2c3",
  "theme": {
    "palette": { "bg": "#0a0a0a", "text": "#fafafa", "accent": "#a3e635" },
    "font": { "heading": "Space Grotesk", "body": "Inter" },
    "border_radius": "0.5rem",
    "custom_css": ".my-gallery { filter: saturate(1.4); }"
  },
  "tabs": [
    {
      "id": "tab_1",
      "label": "Visual",
      "icon": "camera",
      "modules": [
        {
          "type": "gallery",
          "layout": "masonry",
          "columns": 3,
          "content_ref": "collection:photos_main"
        },
        {
          "type": "embed",
          "source": "youtube",
          "url": "https://youtube.com/watch?v=...",
          "display": "card"
        }
      ]
    }
  ]
}

The schema is the source of truth. The editor manipulates it via drag-and-drop. The renderer reads it and hydrates modules. This means:

  • No server-side rendering per visit. Pages compile to static assets on publish, HTML + CSS + lazy-loaded module shells. Visitors get a CDN-cached page, not a server round-trip.

  • Diffable and versionable. Every edit creates a schema diff. Users get undo history. We get an audit trail.

  • Portable. Export your ghar as a JSON blob. Import it elsewhere. Your data is never locked in.

The page schema lives in Supabase Postgres as a JSONB column with GIN indexing, queryable, fast, and leveraging Supabase's built-in auth and row-level security so users can only edit their own ghars at the database level.

2. The Editor: Puck + Tiptap + Motion

This is the make-or-break piece. Three libraries form the editor core:

Puck (MIT-licensed) is an open-source visual editor for React that already outputs JSON from drag-and-drop. Instead of building a page builder from scratch, you define module components (Gallery, Feed, Blog, etc.) as Puck components, and it handles drag-and-drop, configuration panels, and JSON serialization. Puck's architecture is designed for exactly this, embed it in your app, register your custom components, and get a full visual editor. Saves months of building drag-and-drop primitives.

If Puck proves too opinionated, the fallback is dnd-kit, a lower-level drag-and-drop library with better support for real-time previews, custom animations, and fine-grained interaction control. More work, more flexibility.

Tiptap powers every text surface, the Blog module, Feed posts, About sections. Built on ProseMirror, it's a headless rich text editor with 100+ extensions: slash commands, inline embeds, markdown shortcuts, collaborative editing via Yjs. Headless means you fully control the UI while Tiptap handles the editing engine underneath.

Motion (formerly Framer Motion, 30M+ monthly npm downloads) is what makes the editor feel alive. Spring physics for drag-and-drop, layout animations when modules reorder, AnimatePresence for tab transitions, gesture support for mobile swipe interactions. The difference between "functional page builder" and "this feels incredible" is mostly Motion.

Core interactions:

  • Drag modules from a sidebar onto tabs (Puck + Motion spring animations)

  • Click any module to configure it (Puck config panel, custom styled)

  • Paste any URL anywhere, auto-detect and render embed

  • Rich text editing in any text module (Tiptap)

  • Theme panel with live preview (Motion for transitions between theme changes)

  • "View as visitor" toggle

The key insight: constrained freedom. Users don't get a blank canvas (that's Figma, and it's overwhelming). They get structured building blocks with deep customization within each block. The grid system handles positioning, you can't misalign things or break layout. But within that grid, you control everything visual.

3. Module Rendering: Islands Architecture

Each module type is an independent React component (island) that hydrates on scroll. A page with 6 modules doesn't load 6 bundles upfront, only the visible ones hydrate, the rest lazy-load via Intersection Observer as the user scrolls or switches tabs.

Heavy modules (3D scenes, games, video players) load their runtime dependencies on demand. A ghar with a React Three Fiber avatar doesn't penalize visitors who never scroll to that tab. The R3F ecosystem, drei for helpers, gltfjsx for model conversion, makes it practical to let users upload glTF models and render them as React components without writing WebGL.

Page Shell (static HTML + theme CSS, cached on CDN)
  ├── Tab Nav (client-hydrated, lightweight)
  ├── Module: Gallery (hydrates on visible)
  ├── Module: Feed (hydrates on visible)
  ├── Module: 3D Avatar (hydrates on visible, loads R3F + Three.js)
  └── Module: Blog (hydrates on visible, loads Tiptap renderer)

This keeps initial page loads under 200ms regardless of how complex the ghar is.

4. Embed Engine: Iframely + Fallback Chain

Iframely is an oEmbed proxy supporting 1,900+ publishers, YouTube, Twitter/X, Spotify, SoundCloud, Instagram, LinkedIn, CodePen, Figma, GitHub, and hundreds more. It's open-source and self-hostable, or available as a hosted API. Instead of implementing oEmbed, Open Graph parsing, and iframe fallbacks yourself, Iframely handles the entire chain:

Tier 1: oEmbed: For the ~375 providers that support the spec, Iframely returns structured embed data with rich HTML.

Tier 2: Open Graph fallback: For platforms without oEmbed (LinkedIn, many smaller sites), it scrapes OG meta tags and returns a rich preview card, thumbnail, title, description, favicon.

Tier 3: Sandboxed iframe: If a URL supports iframe embedding but has no metadata, Ghar wraps it in a sandboxed iframe with sensible defaults.

Tier 4: Link card: Worst case, a styled link with favicon. Still better than a raw URL.

All embed metadata is cached server-side in Redis. When a visitor loads a ghar with 10 YouTube embeds, we serve cached metadata, not 10 live API requests.

5. Storage & Media Pipeline: Cloudflare R2 + Workers

Cloudflare R2 for object storage, zero egress fees (unlike S3, where bandwidth kills you at scale). User-uploaded images, video, audio, game bundles, and 3D models all land in R2.

Cloudflare Images handles the image pipeline: auto-compress, convert to WebP/AVIF, generate responsive srcsets, on-demand resizing, all at the edge, no origin server round-trip. Upload an image once, serve optimized variants to every device automatically.

Cloudflare Workers orchestrate the media processing pipeline:

  • Images: Extract dominant color (for loading placeholders), generate blur hashes, strip EXIF data

  • Video: Transcode to HLS via Cloudflare Containers (reads from R2, writes back to R2, no data transfer charges), generate thumbnails, extract duration

  • Audio: Normalize levels, generate waveform data for the music player

  • 3D: Validate glTF files, optimize meshes, generate preview renders

Published ghars compile to static HTML + CSS + JS islands and are pushed to R2, served globally via Cloudflare's CDN. A visitor loading someone's ghar hits an edge node within ~50ms of them, not your origin server.

6. Real-Time & Collaboration

For shared ghars, called parivaar maybe (teams, collectives, bands editing their page together):

Yjs: CRDT framework that handles conflict-free merging of concurrent edits. Two people rearranging modules at the same time? Yjs merges both changes without conflicts. Integrates directly with Tiptap for collaborative blog/feed writing with live cursors.

Liveblocks: Managed WebSocket infrastructure for Yjs. Hosts the collaboration backend at the edge, handles presence (who's online, live cursors), offline sync, and document persistence. Eliminates the need to run your own WebSocket servers. Optional, you could self-host a Hocuspocus server instead, but Liveblocks removes significant ops burden.

7. AI as the Accessibility Bridge

This is where AI changes the equation compared to every previous attempt at this idea.

"Describe your ghar" onboarding: New user types "I'm a musician, I want a dark page with my tracks, a photo gallery, and a blog for lyrics." AI generates a page schema, tabs, modules, theme, as a starting point. The user tweaks from there.

Natural language theming: "Make it feel like a cozy bookshop" adjusts palette to warm browns, sets a paper texture background, picks serif fonts. "More cyberpunk" shifts to neons on black with monospace type.

Content assistance: "Write an about me based on my existing posts" or "Generate a header image for my music tab."

The critical constraint: AI is a starting point, never a cage. Every AI-generated element is fully editable. The user always has final control.

8. Platform & Hosting

Next.js App Router for the platform itself, dashboard, explore directory, user settings, the editor. Server components for SEO on public ghar pages (important for discoverability), client components for the interactive editor.

Supabase for the full backend:

  • Postgres: Page schemas (JSONB), user data, content entries, embed metadata cache

  • Auth: Google, GitHub, email login with row-level security

  • Realtime: Live updates when someone visits your ghar (optional presence indicators)

  • Storage: Backup layer alongside R2, or for smaller assets that don't need the full CDN pipeline

Tech Stack Summary

  • Editor (drag-and-drop): Puck or dnd-kit -- JSON-based visual editor with custom React components

  • Editor (rich text): Tiptap + ProseMirror -- Headless, extensible, collaborative-ready

  • Animations: Motion -- Spring physics, layout animations, gesture support

  • Embeds: Iframely -- 1,900+ publishers, self-hostable, full fallback chain

  • 3D: React Three Fiber + drei -- React-native Three.js with helper ecosystem

  • Collaboration: Yjs + Liveblocks -- CRDT merging, managed WebSocket infra

  • Storage & CDN: Cloudflare R2 + Workers + Images -- Zero egress, edge transforms, container transcoding

  • Database & Auth: Supabase -- Postgres + Auth + RLS + Realtime

  • Framework: Next.js App Router -- SSR for SEO, client components for editor

Discovery & Social Graph

Personal pages need visitors. Four layers:

Following/Feed: Subscribe to ghars. Get a chronological feed of new posts across all the ghars you follow, not algorithmically ranked.

Explore Directory: Browse ghars by category, aesthetic, content type. "Show me music pages with a retro theme." Curated collections and editor picks surface quality.

Mohallas (Neighborhoods): Opt-in clusters of ghars around a shared interest. Like GeoCities neighborhoods or web rings, but modern. A "Pixel Art" mohalla, a "Jazz" mohalla, an "Indie Games" mohalla. Ghars can belong to multiple mohallas.

Web Rings: A literal web ring widget. Add it to your ghar, join a ring, visitors click "next" to discover related ghars. The most web-revival feature possible.

What Good Execution Looks Like

The difference between this working and not is entirely in the feel of the editor and the quality of the defaults.

The editor must feel instant. Every drag, every theme change, every module config must preview in real-time with Motion spring animations. No loading spinners between "I want this" and "I see this." Optimistic UI everywhere, local-first editing with background sync via Yjs, module previews rendered from cached data.

Defaults must be beautiful. If the starting themes look like a 2005 WordPress template, nobody will trust the platform. Default themes need to be opinionated and high-quality, Linear, Vercel, Apple-level design. Users should feel good about their ghar before they customize anything.

The first 60 seconds decide everything. Sign up → describe your vibe (or pick a template) → AI generates a ghar → you see it live → you drag one module to rearrange → you change the accent color → you publish. Under a minute. If onboarding feels like configuring a CMS, it's dead.

Mobile editing can't be an afterthought. Simplified module controls, swipe-to-reorder tabs (Motion gesture support), theme presets over granular sliders. Full desktop editor for power users, first-class phone experience for everyone else.

Custom CSS is the power user escape valve. For the web revival crowd who want to code, a CSS editor that layers on top of the theme system. This makes the platform a spectrum: drag-and-drop for most, CSS for tinkerers, both coexisting. Home for the Neocities crowd and the Noplace crowd simultaneously.

Performance is a feature. Any ghar should load in under 200ms for any visitor, anywhere. 8 modules, a background video, a 3D avatar, still fast. Islands architecture, Cloudflare CDN-first delivery, lazy hydration via Intersection Observer, expressiveness should be free from a performance standpoint.

Embeds must be zero-friction. Paste a URL, see the embed. No "which embed type?" dropdowns, no manual iframe sizing. Iframely handles the complexity invisibly. If embedding a YouTube video feels harder than sharing it on Twitter, the product has failed.

The Bet

The bet is that people want to express themselves online in ways that current platforms don't allow, and the only reason they don't is because it's too hard. Make it easy enough and give them a place that feels like theirs, a ghar, not a profile, and a meaningful number of people will build something personal, weird, and alive.

The internet doesn't have to be dead. It just needs a better home.

Discussion

Add your thoughts

Comments are moderated and will appear after approval.

← Back to all ideas