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

Composing Systems, Not Just Apps

Fullstack. No magic. No black box. Just a request, what it needs, and a response.
Get started

τjs is an orchestration layer built on Fastify, Vite, and React. Routes declare what they need. The request resolves it.

Request boundary not component tree

Section titled “Request boundary not component tree”

τjs defines a clear boundary: everything required for the initial render is orchestrated and 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”

With orchestration and rendering 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)

Start simple. Add orchestration only where you need it.

Section titled “Start simple. Add orchestration only where you need it.”

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

Modular without the runtime complexity

Section titled “Modular without the runtime complexity”

τ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

  • 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”