Overview
Start Here
Installation
Tutorial
Architect App Builder
Todo List App
Beacon Beats Audio Store
UCAL App
Authoring
Dynamic Apps
Static Apps
dev_docs
Why Pharos Feels Different
Architect Builder
Framework
Artifacts & Layout
Configuration
Outbound Email
How to Use CLI
Contracts
YAML Authoring
Action Hooks and Middleware
Feature Transaction Primitives
Generated Surfaces
Declarative CRM
Input Validation
Identity and Tenancy
UI Surface Library
Social Connections
Payment Provider Management
Integration Adapters
Reference
Contract, UI, and Surface Reference
Styling UI Elements
Architect Media Artifacts
API Docs
Use Cases
Dynamic SPAs
Generated Admin and APIs
Scheduling and Marketplaces
Multi-App Hosting
Release Notes
Vision
Pharos Framework

← Back

Pharos is a declarative web-app framework that unifies model-driven generation with absolute developer control. At the core of the ecosystem is Architect, an integrated context builder and application editor that turns a product brief and supporting context into a generated Pharos app ready for export. Instead of forcing you to manually configure separate frontend stacks, API layers, auth systems, and deployment glue for every project, Architect generates your app foundation foundation using standard YAML, SQL, and HTML. This eliminates tedious toolchain setup, allowing your team to immediately customize those generated declarations and run database-backed web apps via Pharos in a fraction of the time.

What Pharos does

Most web apps need the same components:

Eight Pharos framework capability icons: pages, forms, API, data interface, auth, background jobs, monitoring, and payments

To eliminate repetitive infrastructure assembly, Pharos compresses these traditional layers into inherited framework behavior.

Before and after diagram showing traditional assembly layers becoming inherited Pharos framework behavior so declared app logic can stay focused on product workflow

Pharos turns declared routes, actions, data contracts, and templates into app artifacts served by a Rust native runtime. This ensures your application logic stays entirely focused on your unique product workflow.

Who this is for

Pharos is for engineering teams that want to ship fast, maintain lean codebases, and avoid architectural technical debt. It is a highly optimized fit for:

  • Advanced Web Applications & SPAs: Engineering custom, high-velocity apps that require tightly coupled, automatically generated API surfaces and a blazing-fast runtime footprint.
  • Data-Heavy Workflows: Powering complex user experiences, dense tables, dynamic multi-step forms, and intricate application logic.
  • Multi-App Systems & Ecosystems: Managing standardized, multi-app deployments that scale cleanly under a single, highly efficient runtime process.

What Pharos provides

Declarative app modelRoutes, actions, templates, data contracts, policies, migrations, and generated surfaces live in app-owned files that can be read, reviewed, and extended.
Architect app builderDescribe an app, attach context from text, documents, PDFs, images, or voice, then generate Pharos app source with preview routes, validation evidence, and a source export.
Rust native runtimePharos owns request routing, mounted app dispatch, template rendering, static assets, health checks, runtime logging, and shared operational behavior.
Security and access controlSessions, CSRF protection, policy gates, roles, password handling, and conservative generated auth contracts keep app behavior behind explicit boundaries.
Templates and HTMX UIApps keep presentation in app-owned templates, fragments, CSS, icons, and assets while the runtime handles declared actions and targeted updates.
Generated admin and APIDeclarations can produce admin pages, forms, generated surfaces, and JSON API endpoints without app-written controllers or duplicate transport code.
Database and state backendsDynamic apps support database-backed persistence with migrations and runtime state boundaries, including SQLite plus external database options for larger deployments.
Workflows and integrationsActions can connect workflow transitions, scheduled jobs, webhooks, notifications, file records, backup contracts, and target validation through declared contracts.
Multi-app operationsSeveral apps can run under one shared runtime process, each mounted at its own path with shared health, packaging, release, and local validation flows.

How it works

Declarative CRM

Pharos provides CRM building blocks for contacts, organizations, leads, notes, activity, follow-ups and related records. Declarative schemas, queries, actions, policies and UI configure persistence, guarded transactions, access checks and fragment rendering. See Declarative CRM for setup and examples.

Diagram showing Architect accepting text, files, PDFs, images, and voice, generating a Pharos app model and source, validating the app, and exporting a ready scaffolded web app

Whether your project is initially generated by Architect or authored directly from scratch, you can seamlessly transition your app scaffold to clean, easy-to-read code the moment you are ready to customize it.

Diagram showing app folder structure flowing into the Pharos runtime and producing a live application

Next

Start with the Tutorial, then move through Todo List, Beacon Beats, and UCAL as you need more workflow depth.