Skip to content
τjs - Composing systems τjs - Composing systems, not just apps

Composing Systems, Not Just Apps

τjs is an orchestration layer where your request defines data, services, and rendering strategy - deterministically.
Get started

Built on Fastify, Vite, and React, τjs is organised around the request boundary, not the component tree. Routes declare orchestration and intent; rendering (CSR, SSR, streaming) is a downstream execution strategy derived from the request.

Your request owns first-render authority

Section titled “Your request owns first-render authority”

τjs defines a clear boundary: everything required for the initial render is resolved at the request level.

  • Data dependencies are declared before rendering begins
  • Service access is mediated and observable
  • Rendering strategy is chosen before rendering begins, not during render
  • Components do not discover data imperatively during SSR

Supported application structures

Section titled “Supported application structures”

Since orchestration and rendering are resolved at the request boundary, τjs can support multiple application structures within the same system:

  • Single-Page Applications (SPA)
  • Multi-Page Applications (MPA)
  • Build-time Micro-Frontends (MFE)
  • Hybrid per-route composition, where a route can be:
    • a standalone app,
    • part of an MPA,
    • “static” pages via CDN caching of SSR output,
    • or a build-time MFE inside a larger system

Declarative rendering per route

Section titled “Declarative rendering per route”

Any route can explicitly define how it renders, independently of how its data is orchestrated:

  • Client-Side Rendering (CSR)
  • Server-Side Rendering (SSR)
  • Streaming SSR
  • Hydration toggle (enable or disable hydration where needed)

Request-time orchestration (optional depth, per route)

Section titled “Request-time orchestration (optional depth, per route)”

Each route defines, at the request boundary, whether τjs performs orchestration.

  • Initial render data is declared at the route boundary
  • Service access can be mediated through a registry rather than direct imports
  • The request defines which data and services participate in the initial render
  • Rendering remains downstream of orchestration (CSR / SSR / Streaming)
  • Client-side fetching and traditional API patterns remain fully supported alongside request contracts

Scale and structure when you choose

Section titled “Scale and structure when you choose”

τjs gives you room to grow without adding runtime complexity:

  • Compose multiple independently built apps at build time
  • Keep strict boundaries between domains without runtime federation
  • Maintain monolithic-level performance with modular structure
  • Deterministic behavior - consistent across environments and render modes
  • Minimal, overridable defaults - entry points, directory layout, rendering modes

Developer-first through explicit authority

Section titled “Developer-first through explicit authority”
  • Coherent backend + frontend DX built on Fastify and Vite
  • Build-time orchestration via taujs.config.ts
  • Clear, granular control over routing, data loading, rendering, and hydration
  • Server runtime powered by Fastify serving Vite builds and handling SSR/streaming

Next steps

Section titled “Next steps”