For developers

A website platform that still feels like software.

Keep the visual editing experience clients need while building custom behaviour with familiar tools, typed contracts and normal application workflows.

Explore the extension model Browse the marketplace

habitat.site.ts

export default defineSite({
  name: "Hearth & Hollow",
  blocks: [
    hero,
    serviceGrid,
    bookingForm
  ],
  collections: [services, journal]
})

A normal development model around a better editor.

Habitat gives developers a structured foundation without taking away the code, testing and deployment practices that make serious web work maintainable.

Use familiar web technology

Build with Nuxt, Vue, TypeScript and Hono instead of learning a closed template language.

Keep content predictable

Typed blocks, collections and schemas make content safe to render, migrate and reuse.

Extend at clear boundaries

Add blocks, routes, business tools and integrations without forking the core editing experience.

Publish through Journi

Run and test normal code locally, then publish through managed Journi hosting. Talk to us about data-residency requirements.

Add capability without dissolving the product.

You can see what each extension adds, version it with the rest of the site and keep every editing surface inside Habitat.

Blocks

Editor controls · validation · rendering

Define the data, editor fields, defaults and published output together. Studio and the public site use the same definition.

const hero = createBlock({
  type: "hero",
  name: "Hero",
  category: "marketing",
  schema: heroSchema,
  defaults: () => heroDefaults,
  editor: heroEditor,
  render: renderHero
})

Collections

Fields · relationships · detail routes

Model services, locations, people or products as versioned fields, relationships and reusable detail pages.

const services = {
  id: "services",
  name: "Services",
  slug: "services",
  version: 1,
  fields: [
    { id: "title", type: "text", required: true }
  ]
} satisfies CollectionDefinition

Routes and APIs

Hono · Zod · OpenAPI

Add Hono endpoints and integrations beside the website, with validated input and a generated OpenAPI contract.

app.post(apiPath("booking.create"), async (c) => {
  const input = bookingInputSchema.parse(
    await c.req.json()
  )

  return c.json(await createBooking(input), 201)
})

Business tools

Permissions · operations · audit history

Add a focused Studio workspace with explicit operations, state and permissions instead of burying the workflow in a theme.

defineHabitatExtension({
  manifest: bookingsManifest,
  modules: [{
    id: "bookings",
    capability: "bookings",
    apiOperations: ["booking.create", "booking.status"],
    studioSections: ["Operations"],
    stateKeys: ["bookings"]
  }]
})

Build one capability from editor to customer.

Habitat extensions are not isolated widgets. A capability can define what an editor changes, how the public site renders it, which operations it creates and which permissions protect it.

Studiopurpose-built authoring controls and business workspaces
Contractstyped content, validation and stable API boundaries
Published siteresponsive output, search metadata and customer actions

EditorBlock controlsContent fields
Design options
Visibility rules

↔

Shared contractservice.schemaTypes
Validation
Permissions

↔

CustomerService pageResponsive view
Booking action
Search data

A delivery path your team already understands.

Habitat fits source control, testing, review and managed release into one repeatable route.

Compose locally

Run the site, Studio and supporting services together with normal source control and local feedback.

Validate the contracts

Type checks, schemas and generated API contracts catch drift between content, Studio and the published site.

Review the real experience

Preview responsive pages and the editing controls that clients will use before a release is accepted.

Publish with Journi

Ship the versioned site package through Journi hosting while keeping project-specific integrations explicit.

Contracts for people, tools and agents.

The extension model is documented in formats that can be reviewed, generated and tested instead of living only in tribal knowledge.

TypeScript and JSON Schema

Share the same content shape between block code, collection data, editors and validation.

OpenAPI

Use a generated API contract for integrations, client tooling and regression checks.

Agent-readable documentation

Versioned Markdown and llms.txt explain the supported model without asking an agent to infer it from the UI.

Stable diagnostics

Machine-readable validation output makes automation useful in local development and delivery pipelines.

Guardrails for editors. Escape hatches for developers.

Traditional site builders can make bespoke application work awkward. Fully headless stacks can leave clients with a disconnected editing experience and agencies maintaining the glue.

Habitat keeps content structure, visual editing, preview and publishing together, while leaving deliberate boundaries for custom code and integrations.

A better website workflow

Build the parts that make a site distinct.

Start with Habitat's block catalogue, then extend at clear boundaries when the project calls for more.

Browse blocks and extensions See it for agencies