thi-ng/umbrella: 217 Independent TypeScript Libraries Without a Framework

217 Packages, Zero Framework Contracts

The README describes thi-ng/umbrella as "LLM-free, human-made and cared for software, maintained as an ecosystem and anti-framework." That framing is precise: this is not a product you install and configure; it is a collection of 217 individually versioned TypeScript libraries, roughly 185 example projects, approximately 250,000 lines of source code across about 4,350 files, covering domains that rarely share a repository.

Functional programming, reactive dataflow, 2D/3D geometry, WebGL, digital signal processing, pen-plotter toolchains, WASM bindings, color spaces, and more all live here as separate packages, each usable without the others. The README quotes an external description: "A collection of functional programming libraries that can be composed together. Unlike a framework, thi.ng is a suite of instruments and you (the user) must be the composer of. Geared towards versatility, not any specific type of music."

The target audience is engineers who find opinionated frameworks constraining. If you need a specific transducer implementation, a 2D geometry intersection primitive, or a DSP filter chain with TypeScript types and no hidden runtime dependencies, this is the collection to evaluate. Some packages have been in regular development since 2015; the current monorepo structure dates to January 2018.

Repository Layout and Navigation Tools

The monorepo uses three top-level directories: `packages/` holds the 217 library packages, `examples/` holds the roughly 185 example projects, and `tools/` holds build and publishing utilities. Inside `packages/`, the README groups libraries by domain: algorithms and data structures, DSLs, file format and hardware support, frontend and UI, fundamentals, geometry and image processing, iterator and sequence processing, low-level and memory management, maths, network, randomness, reactive programming, and WebGL/GPGPU.

Navigating 217 packages without tooling is impractical. The README provides three navigation tools: a tag browser at demo.thi.ng/umbrella/thing-browser/, a full-text documentation string search at demo.thi.ng/umbrella/rdom-search-docs/, and generated API documentation at docs.thi.ng/. The tag-based search on the main thi.ng website groups packages by capability, which is more useful than scanning the README's flat category list when you have a specific problem in mind.

The repository migrated from GitHub to Codeberg. The README states that the GitHub version is now a read-only mirror and will be deleted. Issues, contributions, and development flow through the Codeberg repository at codeberg.org/thi.ng/umbrella.

Building the Monorepo and Using Individual Packages

Individual packages are distributed as pre-built ESM modules (ES2022 syntax) with TypeScript type declarations and export maps. They are published under the `@thi.ng/` npm scope and versioned independently using the thi.ng/monopub publishing toolchain. End users install individual packages from npm using the `@thi.ng/` package scope documented in each library's own README.

The monorepo root uses Yarn workspaces to manage three workspace groups:

"workspaces": [
    "packages/*",
    "examples/*",
    "tools"
]

Contributors who want to build the entire monorepo run a single command, which triggers esbuild across all packages in parallel:

yarn build

Running the full test suite is a two-step process, first a fast esbuild compilation pass and then per-package test execution:

yarn test

The examples are built separately from the library packages:

yarn build:examples

Documentation generation runs via `yarn doc`, which invokes typedoc across all packages and publishes the results to docs.thi.ng. These workspace commands use the `yarn workspaces foreach -pv` mechanism for parallel verbose execution across the full package set.

Reactive, Geometry, WebGL, and DSP: What the Packages Actually Cover

The reactive programming packages implement a stream and transducer model. Transducers here are composable transformation functions that decouple the source of data from how it is processed. The README describes this as "stream/transducer based dataflow graphs/pipelines/DOM." Alongside reactive streams is a fiber process tree abstraction for ES6 generators, providing cooperative multitasking without a heavy async runtime.

Geometry coverage spans 2D and 3D shape primitives, intersections, conversions, and visualizations. Canvas abstraction and pixel buffer handling are included, along with SVG serialization and conversion. A function collection of more than 900 functions handles nD-vectors and both dense and sparse matrices. Separate packages handle color space conversion, color manipulation via matrices, gradient generation, and dominant color extraction.

The WebGL packages provide a semi-declarative WebGL 1/2 abstraction layer and a DSL for shader functions defined in TypeScript that cross-compiles to GLSL, JavaScript, and VEX. DSP building blocks include oscillators, noise generators, filters, a 1D FFT/IFFT, sample rate converters, and muxers. WASM integration covers bridge APIs and data structure code generators targeting Zig and C11, plus a WASM-based SIMD batch processor for vector data.

Entity component system implementations with optional strided memory layouts are available for data-locality-sensitive workloads. Immutable state management with transacted updates and configurable undo/redo history rounds out the data handling packages. The PEG-style parser combinator packages, the S-expression runtime, and the Forth-style pointfree DSL cover language tooling and custom DSL development.

Package Design: Modularity, Tree Shaking, and the Dependency Policy

Each package is structured to allow fine-grained imports. The README describes the rationale: "highly modular with often only a single function / class (incl. closely related functions) per file to help w/ selective imports and tree shaking." Every package also re-exports its full public API for consumers who prefer a single import entry point.

The dependency policy is strict: packages declare "either none or only @thi.ng internal runtime dependencies (w/ very few exceptions)." Adding one `@thi.ng` package does not silently pull in third-party libraries from outside the ecosystem. Each package README lists its specific dependencies explicitly.

The TypeScript version in the monorepo devDependencies is ^6.0.3, which is what the build toolchain requires for building the monorepo from source. Packages are distributed as pre-compiled ESM distributions with declaration files, so consuming them does not strictly require TypeScript 6; they work in any environment that handles ES2022 ESM modules. Plain JavaScript projects can use the packages since type declarations are optional at runtime.

All packages carry the Apache-2.0 license. The monorepo has existed in its current form since January 2018, and some of the functional programming packages date back to 2015.

Where thi-ng/umbrella Falls Short

Two hundred and seventeen packages with no single entry point creates a real discovery problem. The tag browser and doc search tools reduce it, but evaluating whether a given package fits a specific requirement still means reading individual package READMEs, which vary in depth and completeness. There is no unified getting-started guide that walks a new user through combining packages; the roughly 185 examples are the primary learning resource.

The ESM-only, ES2022 distribution is a hard constraint. Projects using CommonJS module formats, older build tools that cannot process ES2022 syntax, or environments without ES module support cannot use these packages without a separate transpilation step. The README does not document compatibility workarounds for CommonJS consumers.

The monorepo does not publish GitHub releases. Version history lives in per-package changelogs inside the `packages/` directory. Developers who rely on GitHub Releases feeds or notifications for dependency updates will find no central signal. The migration to Codeberg also means that GitHub-centric workflows, including GitHub Actions, GitHub Issues, and Dependabot, do not apply to the primary repository. The GitHub mirror is read-only and scheduled for deletion.

Three.js as a Contrast for WebGL and 3D Work

Three.js is a widely-used JavaScript and TypeScript library for 3D graphics in the browser. It provides a complete scene graph, an integrated material system, built-in geometry loaders, and a renderer that targets both WebGL and WebGPU. The entry point for a 3D scene with Three.js is a small, self-contained setup involving a scene object, a camera, a renderer, and a mesh.

thi-ng/umbrella's WebGL and geometry packages take a different position. There is no scene graph and no integrated material system. Shaders are written as TypeScript functions that cross-compile to GLSL; geometry is built from nD-vector operations in the maths packages and processed through the geometry and canvas packages. The entire stack is compositional rather than integrated.

For straightforward 3D rendering with lighting and shadow maps, Three.js reaches that result faster and with more documented examples. For a generative geometry pipeline that feeds data into a reactive dataflow graph, processes it through 2D/3D primitives, and outputs to both a WebGL canvas and an SVG file, thi-ng/umbrella's compositional model makes the cross-format plumbing direct. The two libraries are not direct substitutes; the choice depends on whether you need integrated 3D scene management or composable low-level primitives.

Editorial conclusion

Engineers who want typed, composable primitives for functional programming, reactive dataflow, 2D/3D geometry, or DSP in TypeScript should evaluate the relevant package categories in thi-ng/umbrella. The key things to verify before adopting: whether your target environment supports ES2022 ESM imports, whether you can accept per-package changelogs instead of a central release feed, and whether you have access to the Codeberg repository for issues and contributions. The collection is not a fit for teams that need a turn-key UI framework, a complete 3D scene management system, or a single documented entry point. The last push to the primary repository was on 2026-09-05.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. Project website
4. README
5. thi-ng/umbrella on GitHub