⚡ Threadr
Work

Systems We’ve Built & Ideas We Stand By

A deeper look at the systems, libraries, and experiments that shape the way we approach concurrency and architecture. These are the tools we build, the patterns we rely on, and the engineering principles that guide how we design software that stays fast, predictable, and weekend-friendly.

Open Source

Libraries we maintain

Spaces where we share composable abstractions and sharp concurrency patterns.

Go

gliter

High-performance pipelines and concurrency primitives that make async orchestration feel effortless.

  • Fan-out/fan-in orchestration
  • Worker pools that stay graceful
  • Retry logic + backpressure baked in
  • Async ergonomics that developers actually enjoy
Python

pipevine

Python’s friendliest async pipeline library with composable stages and clear ergonomics.

  • Structured async pipelines
  • Stateful work pools
  • Multiprocessing × asyncio bridges
  • High-throughput ETL + dataflow
Culture

blazingly.fast

A playful community badge that celebrates open-source experimentation and joyful performance work.

  • Community
  • Humor in engineering
  • Open-source celebration
Rust

rowboat

Columnar dataframe runtime for Rust services that need lightning-fast analytics without leaving memory.

  • Clean, minimal API
  • Fast iteration and indexing
  • Zero unnecessary dependencies
  • Designed for clarity and control

Research

Explorations and experiments

Prototype the hard parts first, keep the signal clean, and ship insights back into production.

Field Notes

Semantic Clustering for Social Trends

Embeddings + FAISS + UMAP + HDBSCAN to surface signal from the social firehose before it spikes.

What we built

  • Multi-stage ingestion (Go + Python)
  • Vector search with FAISS
  • Dimensionality reduction via UMAP
  • Density clustering with HDBSCAN
  • Live enrichment & analytics

Why it matters

Find hidden patterns behind viral behavior before they break out.

Systems

Professional platforms

Quiet backbones that keep products online and teams moving without drama.

Systems

End-to-End Auth System (Zero Dependencies)

Self-contained auth platform with fine-grained permissions and secure token flows — built to run in isolated, high-security environments.

  • Users, roles, groups, tenants
  • Fine-grained permission engine
  • JWT lifecycle + httpOnly refresh cookies
  • Full frontend integration with interceptors + state
Systems

Event-Driven Architectures with Redis & GCP

Redis pub/sub, queues, and GCP Task Queues powering async workflows teams can evolve independently.

  • Event sourcing
  • Fan-out event pipes
  • Queue-backed async jobs
  • Decoupled services + modular workflows
Systems

High-Impact Performance Tuning

Algorithm, SQL, and caching overhauls that turned a sluggish alerts dashboard into a realtime system.

  • Massive load reduction
  • Faster interactions
  • Predictable response times
  • Healthier downstream systems
Systems

Multi-Tenant CRM Sync Engine

State-sync backbone that mirrors millions of CRM records into product data stores with deterministic freshness windows.

  • Tenant-aware change capture
  • Adaptive batching + throttling
  • Conflict-safe merge routines
  • Realtime fan-out APIs

Principles

How we think

Constraints and defaults that keep work clean, modular, and understandable.

🧅

Onion Architecture

Domains inside, services around them, adapters on the edge. Clear seams keep the system legible for years.

🧵

Parallel-First Design

Pick tools that love concurrency, then build abstractions that make parallel work reliable.

🧩

Event-Driven Modularity

Redis or queue-backed messaging as the central backbone for teams to ship without stepping on each other.

Ready to build?

Build with Threadr

Let’s architect something fast, reliable, and resilient enough to survive real-world load without weekend pages.