Aglyn is a multi-tenant website-builder platform that turns a live, clickable canvas
into a real business website — no code, no ceremony, no expensive rebuilds.

aglyn.com  ·  Console  ·  Docs  ·  Contributing  ·  Report a bug

Aglyn takes the pain out of getting a professional website off the ground. Instead of hiring engineers or wrestling with templates, you build on a live, clickable canvas — the Besigner — where what you click is what you ship. Every element, page, and interaction is editable in place, and publishing is instant across a globally-served, multi-tenant runtime.

It's a full platform, not just an editor: organizations, billing, a plugin marketplace, a digital asset manager, e-commerce, bookings, email, workflows, and a documented REST API all live under one roof.

Three surfaces, one platform · aglyn.com — the marketing site · app.aglyn.com — where you build, manage orgs & billing · aglyn.app + your own custom domain — where your published site is served to the world

The Besigner — a clickable, in-place canvas where design and content live on the same surface.

Console dashboard — traffic, users, campaigns & activity at a glance

Built-in commerce — products, pricing, orders & POS

An Nx workspace organized into deployable apps and shareable libs.

aglyn/
├─ apps/
│  ├─ 🌐 www        → marketing site               (aglyn.com)
│  ├─ 🛠️ console     → dashboard, editor, billing    (app.aglyn.com)
│  ├─ 🚀 tenant      → runtime for published sites   (aglyn.app + custom domains)
│  └─ 📖 docs        → Docusaurus documentation
│
├─ libs/
│  ├─ aglyn                 → core platform library
│  ├─ aglyn-node-renderer   → server-side screen renderer
│  ├─ besigner/             → the clickable visual editor (core + designer)
│  ├─ tenant/runtime        → shared tenant runtime (host events + composition)
│  ├─ plugins/              → bookings · commerce · community · contacts · data
│  │                          email · events-calendar · inbox · logic · marketing
│  │                          mui · redirects · workflows
│  └─ shared/               → data · ui · util building blocks
│       ├─ data/  → enums · forms · mdi · regex · types
│       ├─ ui/    → jsx · jsx-forms · theme · color-picker · json-editor · next · …
│       └─ util/  → dom · email · errors · fbclient · fbserver · http · logger · …
│
└─ cloud/          → Firebase (functions, Firestore/Storage rules, Remote Config)

Library conventions — each lib is one of four types, so dependencies stay predictable:

• Feature — smart UI with data access, for a specific business use case.
• UI — presentational ("dumb") components only.
• Data-access — back-end interaction and state management.
• Utility — low-level helpers shared broadly.

Prerequisites: Node ≥ 24, npm, and the Firebase CLI for local emulation.

# 1. Install dependencies
npm install

# 2. Copy the example environment and fill in the blanks
cp .env.example .env

# 3. Serve an app (console, tenant, www, or docs)
npx nx serve console

The dev server hot-reloads on http://localhost:4200. Use --prod for a production build.

# Start the emulators (imports/exports local data)
firebase emulators:start --import=./.firebase --export-on-exit

# Serve the console wired to the emulators
npm run serve:console:emulated

Default emulator hosts: Firestore localhost:8082, Auth localhost:9099. See docs/E2E_LOCAL.md for the full local end-to-end recipe.

Run the whole platform on your own infrastructure with Docker — any cloud, a VPS, or bare metal — pointed at your own Firebase project and your own Stripe/Resend keys:

cp .env.selfhost.example .env.selfhost   # fill it in
docker compose up --build

Console on :4200, published sites on :4500, your reverse proxy in front. The full runbook — Firebase project setup, security-rules deploy, DNS, and the honest limits (Firebase is required; the in-console custom-domain flow is Vercel-only) — lives in docs/SELF_HOSTING.md.

Scaffolding new projects:

nx g @nx/next:app <app-name>     # new Next.js app
nx g @nx/react:lib <lib-name>    # new React library
nx g @nx/react:component <name> --project=<app>

Libraries are shareable and imported as @aglyn/<name> (e.g. @aglyn/shared-ui-jsx).

📚 Full product & developer docs live at docs.aglyn.com.

Repo-local deep-dives live in docs/, including:

• Self-hosting · Multi-tenant Firestore · Platform provisioning
• Plugin loading · Plugin platform gaps
• Rate limiting · Security content review
• Email setup · Stripe go-live · Commerce token signing
• Vercel deployments · Build performance · TypeScript 7

We follow Conventional Commits — commit messages are linted.

<type>[(optional-scope)]: <description>

[optional body]

[optional footer(s)]

Common types: feat (new feature → minor), fix (bug patch → patch), plus build, chore, ci, docs, style, refactor, perf, test, and revert. A ! after the type/scope or a BREAKING CHANGE: footer signals a major change.

See CONTRIBUTING.md, the Code of Conduct, and SECURITY.md before opening a PR.

• Organization — the entity that owns sites, members, and billing.
• Workspace — the UX word for an organization's working area.
• Tenant — a site at runtime (the served, published surface only).
• Besigner — Aglyn's clickable visual editor.
• Plugin / Add-on — pluggable, first- or third-party modules that extend an org or app while respecting its architecture.
• Extension — deeper, non-standard integrations that modify default behavior; typically community-authored.

Aglyn LLC is a distributed technology company building the clickable way to create online. We're improving the no-code web-development market by shrinking the distance between an idea and a live, professional website — easing maintenance and minimizing the expensive engineering work a business site usually demands.

Apache License 2.0 · © Aglyn LLC