# The use-case library: 50 domains, worked

Reference for the `vamo-search` skill. Parameters used here (`q`, `orgs`, `techs`, `lang`, `pastCompanies`, `minCracked`, `maxCracked`, `depth`, `similar?login=`) are described in section 4 of `sourcing-guide.md`.

This library is where most of the daily value lives. Each entry is built around one idea: **what does this developer build on the weekend, when nobody is paying them?** That is the tell of what they care about, and what they care about is what makes them great at your role and likely to reply to it.

**Do the fan-out in your head before you touch Vamo.** The strongest recall comes from thinking like the person first: if someone genuinely loved this problem, what would they have built, and how would they describe it? Write three to six of those descriptions as separate `q` phrasings, name a seed person or a canonical repo or an org, and only then run the searches. The query is the last step, not the first. A minute of "what would a real one have made" beats ten queries of guesswork.

**What surfaces a real one.** Vamo reads real work: the repositories a person keeps returning to, what the README actually explains (the hard part they solved, not just usage), the stack they reach for without being asked, whether their work is respected by builders whose own work is serious, and whether the activity is recent and sustained. So a good `q` describes the _work and the artifact_, and a good qualify step reads the repo and the trajectory, not a label. The entries below each note the evidence that answers them.

Org, repository and company values are placeholders: fill them with the projects and employers that define the space for your role. Each entry gives: the weekend-builder read, phrasings to run as separate searches, ways to widen, the evidence that surfaces a real one, and a qualify tell plus a bridge angle. Default to the gettable band `minCracked=70&maxCracked=88` on senior roles, and `depth=core` for recall.

---

### Systems and infrastructure

**1. Distributed systems and databases** _Weekend build:_ a consensus library or a toy database they wrote to understand the hard part, then could not stop polishing. _Phrasings:_ `raft consensus implementation from scratch` · `lsm-tree storage engine, compaction, write amplification` · `distributed transaction coordinator, MVCC, snapshot isolation` · `gossip membership protocol, failure detection` · `write-ahead log, crash recovery, durability`. _Widen with:_ `similar?login=<a-known-db-builder>` · `orgs=<orgs behind the canonical projects>` · `techs=rust,go` · adjacent: storage engines, consensus, streaming. _Surfaces a real one:_ a repo whose README describes a correctness problem (linearizability, leader leases), not a CRUD app; multiple returns to the same storage theme. _Tell / Bridge:_ a storage or consensus repo mapping to a must-have. // "Your `raft` handles leader-lease reads, which is the exact correctness gap our storage tier has open."

**2. Storage engines and filesystems** _Weekend build:_ a key-value store, a FUSE filesystem, a caching layer they benchmarked obsessively. _Phrasings:_ `b-tree and lsm-tree internals, page cache` · `FUSE filesystem, userspace storage` · `content-addressed storage, dedup, merkle trees` · `io_uring, async disk io, direct io` · `embedded key-value store, mmap`. _Widen with:_ `similar?login=<seed>` · `techs=rust,c,cpp` · adjacent: databases, OS internals. _Surfaces a real one:_ benchmark numbers and design notes in the README; io or memory-layout focus. _Tell / Bridge:_ real on-disk format work. // "Your mmap-based store and its back-pressure handling is the shape of our new cache tier."

**3. Compilers, languages, and PLT** _Weekend build:_ their own programming language, a bytecode VM, a garbage collector, a type checker. _Phrasings:_ `compiler backend, SSA, register allocation` · `type inference, hindley-milner, bidirectional` · `hand-written parser and lexer, no generators` · `bytecode VM, interpreter, garbage collector` · `LLVM frontend, IR generation`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,ocaml,haskell` · adjacent: interpreters, static analysis, DSLs. _Surfaces a real one:_ a language or compiler with real semantics, not a calculator; commits over years, because language people never finish. _Tell / Bridge:_ a working language or backend. // "Your type-inference engine in `<repo>` is the layer we are rebuilding."

**4. Operating systems, kernel, and eBPF** _Weekend build:_ a hobby OS, a kernel module, eBPF programs to see what the machine is really doing. _Phrasings:_ `hobby operating system, bootloader, scheduler` · `linux kernel module, character device driver` · `eBPF programs, XDP, packet filtering` · `bare-metal, interrupt handlers, memory management` · `unikernel, microkernel design`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=c,rust` · adjacent: embedded, networking dataplane. _Surfaces a real one:_ register-level or ring-0 code; a README that explains the boot or scheduling design. _Tell / Bridge:_ real kernel or eBPF work. // "Your XDP packet path is exactly the dataplane we are building."

**5. Networking, proxies, and dataplane** _Weekend build:_ a userspace TCP stack, an HTTP proxy, a load balancer they wrote to understand the wire. _Phrasings:_ `userspace tcp stack, congestion control` · `http proxy, connection multiplexing, http/2` · `high-performance networking, DPDK, zero-copy` · `load balancer, consistent hashing` · `QUIC implementation, packet pacing`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,go,c` · adjacent: kernel, observability. _Surfaces a real one:_ protocol-level code with throughput focus; not a proxy config file. _Tell / Bridge:_ a real proxy or stack. // "Your connection-multiplexing design is the core of our new edge."

**6. Observability, profiling, and performance** _Weekend build:_ a sampling profiler, a flame-graph tool, a tracing library, because they cannot stand not knowing where the time goes. _Phrasings:_ `sampling profiler, flame graphs, stack unwinding` · `distributed tracing, opentelemetry internals` · `high-cardinality metrics storage` · `continuous profiling with eBPF` · `latency measurement, tail latency, histograms`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=go,rust` · adjacent: performance, kernel. _Surfaces a real one:_ a profiler or tracing internals repo; perf writeups. _Tell / Bridge:_ real profiling internals. // "Your continuous profiler and its overhead budget is what our platform needs."

**7. Embedded, firmware, and RTOS** _Weekend build:_ firmware for a board they own, an RTOS port, a driver, embedded Rust. _Phrasings:_ `bare-metal firmware, rtos, interrupt handlers` · `embedded rust, no_std, peripheral drivers` · `low-power wireless, BLE, LoRa, zigbee` · `hardware abstraction layer, register maps` · `bootloader, OTA firmware update`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,c` · adjacent: IoT, hardware hacking, robotics. _Surfaces a real one:_ register-level drivers, timing constraints in the README. _Tell / Bridge:_ real firmware. // "Your no_std driver for `<chip>` is the exact platform we are on."

**8. Air-gapped and secure infrastructure** _Weekend build:_ offline-first tooling, artifact signing, sealed secrets, hardening scripts. _Phrasings:_ `air-gapped deployment, offline container registries` · `software supply chain, artifact signing, SBOM` · `hardened kubernetes, admission control, policy` · `secure key storage, HSM, sealed secrets` · `reproducible builds, provenance`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=go` · adjacent: security, k8s internals. _Surfaces a real one:_ offline or signing focus; subject fit outweighs star count here, so do not gate on stars. _Tell / Bridge:_ an air-gap or signing repo. // "You solved offline key storage in `<repo>`; that is our whole problem."

**9. Kubernetes and orchestration internals** _Weekend build:_ a custom controller, an operator, a scheduler plugin, because they wanted to bend the control plane. _Phrasings:_ `kubernetes operators, custom controllers, reconciliation` · `CRDs, admission webhooks` · `scheduler plugins, bin packing` · `container runtime, OCI, cgroups, namespaces` · `service mesh data plane`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=go` · adjacent: infra, networking. _Surfaces a real one:_ a controller with a real reconciliation loop, not a helm chart. _Tell / Bridge:_ a real operator. // "Your reconciliation design in `<repo>` is the pattern our platform runs on."

**10. Build systems and developer tooling** _Weekend build:_ a faster build tool, a linter, a codegen, an LSP, because slow tooling is a personal insult. _Phrasings:_ `build system internals, incremental compilation, caching` · `language server protocol, editor tooling` · `codegen, ast transforms, macros` · `cli ergonomics, developer experience libraries` · `monorepo tooling, dependency graphs`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,go` · adjacent: compilers, DX obsessives (entry 44). _Surfaces a real one:_ tools built for other developers, repeatedly; adoption by peers. _Tell / Bridge:_ a real dev tool with users. // "Your incremental build cache is the friction we are removing for our team."

### AI and machine learning

**11. LLM agents and tooling** _Weekend build:_ an agent framework, an eval harness, an MCP server, a tool-calling loop they kept refining. _Phrasings:_ `llm agent frameworks, tool calling, function schemas` · `eval harnesses for language models, graders` · `MCP servers, structured tool use` · `agent memory, planning, reflection loops` · `prompt-to-structured-output, json mode, constrained decoding`. _Widen with:_ `similar?login=<a-known-agent-builder>` · `techs=python,typescript` · adjacent: RAG, evals. _Surfaces a real one:_ eval or agent-loop code, not a prompt collection; recent and fast-moving. _Tell / Bridge:_ a real eval or agent framework. // "Your grader design in `<repo>` is exactly how we measure our agents."

**12. ML training infrastructure** _Weekend build:_ a from-scratch training loop, a distributed-training experiment, an autograd engine. _Phrasings:_ `training-loop engineering, mixed precision, gradient accumulation` · `distributed data parallel, FSDP, sharding` · `autograd engine from scratch` · `checkpointing, resumable training` · `data loading pipelines for training, sharded datasets`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=python,cuda` · adjacent: inference, GPU kernels. _Surfaces a real one:_ infra code around models, not notebooks; reproductions of real training. _Tell / Bridge:_ real training infra. // "Your FSDP checkpointing is the piece our training stack is missing."

**13. Inference, serving, and GPU kernels** _Weekend build:_ a fast inference server, a custom CUDA or Triton kernel, a quantization experiment. _Phrasings:_ `inference serving, continuous batching, KV cache` · `CUDA kernels, triton, fused ops` · `quantization, int8, gptq, awq` · `speculative decoding, paged attention` · `model compilation, tensorrt, onnx`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=cuda,cpp,python` · adjacent: training infra, perf. _Surfaces a real one:_ kernel or serving code with latency numbers. _Tell / Bridge:_ real kernel or serving work. // "Your paged-attention kernel is the throughput win we need."

**14. RAG, retrieval, and vector search** _Weekend build:_ a vector index from scratch, a hybrid retriever, a chunking and reranking pipeline. _Phrasings:_ `vector search, ANN, HNSW from scratch` · `hybrid retrieval, bm25 plus embeddings` · `chunking strategies, semantic splitting` · `reranking, cross-encoders` · `embedding pipelines, index building at scale`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,python` · adjacent: search/IR, LLM tooling. _Surfaces a real one:_ index internals or a real retrieval pipeline, not a library wrapper. _Tell / Bridge:_ a real retrieval build. // "Your HNSW implementation and its recall tuning is the retrieval core we are building."

**15. Computer vision and imaging** _Weekend build:_ an object detector, a SLAM experiment, a custom image kernel, a camera project. _Phrasings:_ `object detection, segmentation, training pipelines` · `camera calibration, structure from motion` · `image processing, custom kernels, GPU` · `real-time vision, edge deployment` · `optical flow, tracking`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=python,cpp,cuda` · adjacent: robotics, video. _Surfaces a real one:_ vision algorithms or pipelines with real data. _Tell / Bridge:_ real vision work. // "Your calibration pipeline is the perception layer we need."

**16. Speech, voice, and audio AI** _Weekend build:_ a real-time voice agent, a streaming ASR toy, a diarization experiment. _Phrasings:_ `low-latency voice agents, turn-taking, barge-in` · `streaming ASR and TTS, realtime inference` · `webrtc audio transport, jitter buffers` · `voice activity detection, endpointing` · `speaker diarization, wake word`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=python,rust` · adjacent: audio DSP, ML infra. _Surfaces a real one:_ a repo about audio latency and transport, not an API wrapper. _Tell / Bridge:_ real realtime audio. // "Your barge-in handling cancels TTS inside 80ms, our exact responsiveness bar."

**17. ML research reproductions (paper implementers)** _Weekend build:_ clean-room implementations of papers, because reading is not understanding until it runs. _Phrasings:_ `from-scratch implementation of transformer, attention` · `reproducing research papers, minimal implementations` · `annotated model implementations, educational` · `diffusion models from scratch` · `reinforcement learning algorithms implemented`. _Widen with:_ `similar?login=<a-known-paper-implementer>` · `techs=python` · adjacent: training infra, evals. _Surfaces a real one:_ multiple faithful reimplementations with clear writeups; a habit, not a one-off. _Tell / Bridge:_ a body of clean reproductions. // "Your minimal `<paper>` implementation is exactly the clarity our research code needs."

**18. Evals, reliability, and model safety tooling** _Weekend build:_ eval suites, red-team harnesses, guardrail libraries. _Phrasings:_ `eval harnesses, benchmark suites for models` · `red teaming, adversarial prompts, jailbreak testing` · `guardrails, output validation, structured checks` · `hallucination detection, groundedness` · `model observability, drift detection`. _Widen with:_ `techs=python` · adjacent: LLM tooling, appsec. _Surfaces a real one:_ eval or safety code with real methodology, not blog posts. _Tell / Bridge:_ a real eval suite. // "Your groundedness checks are the reliability layer we are adding."

### Domain-driven and mission work

**19. Climate, energy, and geospatial** _Weekend build:_ emissions calculators, grid models, satellite-data notebooks, because they care about the planet. _Phrasings:_ `climate data pipelines, emissions accounting` · `energy grid modeling, renewables forecasting` · `geospatial analysis, satellite imagery, remote sensing` · `carbon measurement, life-cycle analysis` · `weather and climate simulation`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=python` · adjacent: data eng, scientific computing. _Surfaces a real one:_ repos thematically climate even when the stack varies; the caring is the signal. _Tell / Bridge:_ a climate repo. // "Your emissions pipeline is the mission and the exact system we are building."

**20. Robotics and control** _Weekend build:_ a robot arm, a drone controller, a SLAM stack, a ROS project in the garage. _Phrasings:_ `ROS nodes, motion planning, MoveIt` · `SLAM, sensor fusion, kalman filters` · `real-time control loops, PID, trajectory optimization` · `robot simulation, MuJoCo, Isaac, Gazebo` · `inverse kinematics, manipulation`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=cpp,python,rust` · adjacent: embedded, computer vision. _Surfaces a real one:_ control-loop or perception code, hardware in the loop. _Tell / Bridge:_ a real control or perception subsystem. // "Your trajectory optimizer is the control layer we need."

**21. Bioinformatics and computational biology** _Weekend build:_ sequence-alignment tools, single-cell pipelines, protein-folding experiments. _Phrasings:_ `genomic sequence alignment, variant calling` · `single-cell RNA analysis pipelines` · `protein structure, molecular dynamics, folding` · `bio data pipelines, nextflow, snakemake` · `phylogenetics, tree building`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=python,rust,r` · adjacent: scientific computing, data eng. _Surfaces a real one:_ pipeline or algorithm code with real biology, not coursework. _Tell / Bridge:_ a bio pipeline. // "Your variant-calling pipeline is the exact analysis our platform runs."

**22. Healthcare and clinical data** _Weekend build:_ FHIR parsers, DICOM viewers, health-data plumbing, often from lived experience. _Phrasings:_ `FHIR, HL7, clinical data pipelines` · `medical imaging, DICOM, viewers` · `HIPAA-aware systems, PHI handling, de-identification` · `clinical decision support` · `wearable and sensor health data`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=python,typescript` · adjacent: data eng, vision. _Surfaces a real one:_ real health-data interop or imaging code. _Tell / Bridge:_ a health-data repo. // "Your FHIR pipeline is the interoperability layer we are building."

**23. Fintech, payments, and ledgers** _Weekend build:_ a double-entry ledger, a trading-data toy, a reconciliation script; but often it lives at work, so qualify on history too. _Phrasings:_ `double-entry ledgers, idempotent payment APIs` · `reconciliation, exactly-once money movement` · `card processing, PCI, tokenization` · `high-throughput transaction systems` · `order matching, trading systems`. _Widen with:_ `pastCompanies=<companies whose product is the domain>` · `techs=go,rust,java` · adjacent: distributed systems. _Surfaces a real one:_ a ledger repo is a bonus; ex-payments tenure is the evidence when public code is thin. _Tell / Bridge:_ ledger repo or payments tenure. // "You built the ledger core at `<company>`; we are standing ours up now."

**24. Crypto, protocol, and zero-knowledge** _Weekend build:_ a consensus toy, a zk circuit, a from-scratch blockchain, because the cryptography is the fun. _Phrasings:_ `consensus protocol implementation, BFT` · `zero-knowledge proofs, circuits, snarks, starks` · `evm internals, smart contract security` · `p2p networking, libp2p, kademlia` · `cryptographic primitives, elliptic curves`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,go,circom` · adjacent: cryptography, distributed systems. _Surfaces a real one:_ protocol or proof-system code, not a token contract. _Tell / Bridge:_ real protocol or zk work. // "Your circuit for `<thing>` is the proof system we are designing around."

**25. Security, appsec, and offensive** _Weekend build:_ CTF tools, fuzzers, exploit writeups, a sandbox escape for fun. _Phrasings:_ `fuzzing harnesses, coverage-guided, libfuzzer` · `exploit development, memory corruption, mitigation bypass` · `web security, sast, taint analysis` · `sandbox escapes, container breakout` · `reverse engineering, binary analysis`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=c,cpp,rust,python` · adjacent: cryptography, kernel. _Surfaces a real one:_ real vuln or fuzzing work, CTF pedigree, writeups, not awareness slides. _Tell / Bridge:_ a fuzzer or exploit chain. // "Your coverage-guided fuzzer is exactly the hardening our product needs."

**26. Applied cryptography** _Weekend build:_ constant-time implementations, a TLS toy, a password hasher, an encrypted-notes app. _Phrasings:_ `applied cryptography, constant-time implementations` · `TLS implementation, handshake, key exchange` · `end-to-end encryption, double ratchet, signal protocol` · `password hashing, argon2, key derivation` · `post-quantum cryptography`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,go,c` · adjacent: security, protocols. _Surfaces a real one:_ primitives with correctness and timing care in the README. _Tell / Bridge:_ a real crypto implementation. // "Your double-ratchet implementation is the E2E layer we are adding."

**27. Maps, routing, and geospatial systems** _Weekend build:_ a routing engine, a vector-tile renderer, a GPS-track analyzer, a transit app. _Phrasings:_ `routing engines, contraction hierarchies, A* at scale` · `map rendering, vector tiles, mapbox gl` · `geospatial indexing, r-trees, h3, s2` · `GPS trajectory processing, map matching` · `isochrones, travel-time analysis`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=cpp,rust,go` · adjacent: data structures, viz. _Surfaces a real one:_ routing or tiling internals, not a maps API demo. _Tell / Bridge:_ a routing engine. // "Your contraction-hierarchy routing is the core of our logistics engine."

**28. Scientific computing, simulation, and HPC** _Weekend build:_ an N-body sim, a fluid solver, a numerical library, a CUDA physics toy. _Phrasings:_ `numerical methods, PDE solvers, finite element` · `fluid dynamics simulation, CFD` · `N-body simulation, particle systems` · `high-performance computing, MPI, OpenMP` · `differentiable simulation`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=julia,cpp,fortran,cuda` · adjacent: graphics, robotics. _Surfaces a real one:_ a solver or numerical library with real math. _Tell / Bridge:_ a simulation repo. // "Your PDE solver is the numerics core our product is built on."

**29. Aerospace, spacecraft, and flight** _Weekend build:_ a flight-sim autopilot, a rocket-telemetry tool, a spaceflight-sim mod, orbital-mechanics code. _Phrasings:_ `flight control, autopilot, PX4, ardupilot` · `orbital mechanics, trajectory propagation` · `telemetry systems, ground station software` · `guidance navigation control, GNC` · `sensor fusion for flight`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=cpp,python,rust` · adjacent: robotics, control, embedded. _Surfaces a real one:_ GNC or telemetry code; a deep hobbyist streak. _Tell / Bridge:_ real flight or orbital code. // "Your trajectory propagator is the GNC layer we need."

**30. AgTech, hardware, and sensing** _Weekend build:_ a garden sensor network, a computer-vision plant classifier, a soil-data logger. _Phrasings:_ `sensor networks, environmental monitoring` · `computer vision for agriculture, crop detection` · `time-series sensor data, edge logging` · `drone imagery analysis, NDVI` · `IoT data pipelines for the field`. _Widen with:_ `techs=python,cpp` · adjacent: IoT, embedded, vision, climate. _Surfaces a real one:_ real sensor or field-data projects, hardware plus data. _Tell / Bridge:_ a sensing or field repo. // "Your edge sensor pipeline is exactly our data-collection layer."

### Product and craft

**31. Frontend craft and design engineering** _Weekend build:_ an animation library, an accessible component set, a micro-interaction playground. _Phrasings:_ `animation and interaction, spring physics, gestures` · `design systems, component primitives, accessibility` · `performance, virtualization, render scheduling` · `headless UI, composable components` · `SVG and canvas UI, custom rendering`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=typescript` · adjacent: creative coding, real-time collab. _Surfaces a real one:_ craft repos (animation, a11y, perf), not CRUD apps; taste visible in demos. _Tell / Bridge:_ a craft repo with polish. // "Your gesture-driven animation lib is the interaction quality we are chasing."

**32. Graphics, shaders, and creative coding** _Weekend build:_ shader art, a raytracer, a generative-art sketchbook, a WebGL toy. _Phrasings:_ `real-time rendering, deferred shading, PBR` · `GLSL and HLSL shaders, GPU pipelines` · `ray tracing, path tracing from scratch` · `generative art, creative coding, WebGL` · `mesh processing, geometry`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=cpp,rust,glsl,javascript` · adjacent: game engines, viz. _Surfaces a real one:_ a renderer or shader body of work; visual proof. _Tell / Bridge:_ a renderer or shader set. // "Your deferred renderer is the pipeline our product is built on."

**33. Game engines and gamedev** _Weekend build:_ their own engine, an ECS, a physics library, a game jam entry every few months. _Phrasings:_ `custom game engine, ECS architecture` · `physics engine, collision, rigid body` · `game networking, rollback netcode, lockstep` · `procedural generation, noise, worldgen` · `real-time rendering for games`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,cpp,csharp` · adjacent: graphics, physics. _Surfaces a real one:_ an engine or subsystem, not a game made in someone else's engine. _Tell / Bridge:_ an engine subsystem. // "Your rollback netcode is exactly our multiplayer core."

**34. Mobile depth (iOS and Android)** _Weekend build:_ custom rendering with Metal, a jank-free list, an offline-sync toy app. _Phrasings:_ `custom rendering on iOS, Metal, Core Animation` · `android performance, jank, frame pacing` · `offline-first sync, conflict resolution on mobile` · `native modules, JSI, bridging` · `custom layout engines on mobile`. _Widen with:_ `techs=swift,kotlin` · adjacent: local-first, frontend craft. _Surfaces a real one:_ platform-depth repos, not a tutorial app. _Tell / Bridge:_ a mobile-depth repo. // "Your Metal rendering path is the performance layer our app needs."

**35. Local-first, offline, and CRDT** _Weekend build:_ a CRDT library, an offline note app, a sync engine, because they believe software should work without the cloud. _Phrasings:_ `CRDT implementation, conflict-free replication` · `local-first software, sync engines` · `offline-first, eventual consistency` · `operational transforms versus CRDTs` · `peer-to-peer sync, end-to-end`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,typescript` · adjacent: real-time collab, distributed systems. _Surfaces a real one:_ a sync or CRDT library, a stated local-first conviction. _Tell / Bridge:_ a CRDT or sync repo. // "You have shipped three CRDT libraries; we are moving our editor onto CRDTs and want that judgement."

**36. Real-time collaboration** _Weekend build:_ a collaborative editor, a shared whiteboard, a presence system. _Phrasings:_ `collaborative editing, operational transform, CRDT` · `presence and awareness, cursors, live sync` · `multiplayer canvas, shared whiteboard` · `websocket sync, conflict resolution` · `real-time document engine`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=typescript,rust` · adjacent: local-first, frontend. _Surfaces a real one:_ a real sync engine or collab demo, not a chat app. _Tell / Bridge:_ a collab engine. // "Your presence-sync design is exactly our multiplayer layer."

**37. Audio, music tech, and DSP** _Weekend build:_ a synth, a VST plugin, a DAW experiment, a guitar-effects pedal in code. _Phrasings:_ `digital signal processing, filters, FFT` · `audio synthesis, synthesizers, oscillators` · `VST and audio plugins, JUCE` · `real-time audio, low-latency, lock-free` · `music information retrieval, beat detection`. _Widen with:_ `techs=cpp,rust` · adjacent: speech AI, graphics. _Surfaces a real one:_ DSP or synth code with real-time care. _Tell / Bridge:_ an audio or DSP repo. // "Your lock-free audio path is the latency work our product needs."

**38. AR, VR, and spatial** _Weekend build:_ a hand-tracking demo, a spatial-mapping toy, a WebXR sketch. _Phrasings:_ `AR and VR, spatial tracking, SLAM` · `hand and body tracking, pose estimation` · `WebXR, immersive web` · `spatial audio, 3D scene reconstruction` · `passthrough, mixed reality`. _Widen with:_ `techs=cpp,csharp,typescript` · adjacent: graphics, computer vision, robotics. _Surfaces a real one:_ real spatial or tracking code, not a store-bought asset reskin. _Tell / Bridge:_ a spatial-tracking repo. // "Your hand-tracking pipeline is the interaction layer we are building."

### Data

**39. Data engineering and streaming** _Weekend build:_ a streaming pipeline, a CDC toy, a from-scratch mini-warehouse. _Phrasings:_ `streaming pipelines, exactly-once, kafka, flink` · `change data capture, debezium, log-based` · `data warehouse modeling, dbt, incremental` · `orchestration, airflow, dagster internals` · `columnar storage, parquet, arrow internals`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=python,scala,rust` · adjacent: analytics engines, distributed systems. _Surfaces a real one:_ pipeline internals, not dashboard SQL. _Tell / Bridge:_ a streaming or CDC repo. // "Your exactly-once CDC design is the ingestion core we need."

**40. Analytics, columnar, and query engines** _Weekend build:_ a SQL engine, a vectorized executor, a query planner, because databases are art. _Phrasings:_ `query engine, vectorized execution` · `SQL parser and planner, optimizer` · `columnar formats, arrow, compression` · `OLAP engine, aggregation, group-by` · `embedded analytics, in-process OLAP`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,cpp` · adjacent: databases, data eng. _Surfaces a real one:_ a query engine or executor, not BI dashboards. _Tell / Bridge:_ a real query engine. // "Your vectorized executor is exactly our analytics core."

**41. Search and information retrieval** _Weekend build:_ an inverted index, a search engine, a ranking experiment. _Phrasings:_ `inverted index, bm25, query parsing` · `search engine from scratch, tokenization` · `learning to rank, relevance tuning` · `faceted search, aggregations` · `typo tolerance, fuzzy matching, tries`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=rust,go,java` · adjacent: vector search, analytics. _Surfaces a real one:_ index or ranking internals, not a wrapper around a hosted search service. _Tell / Bridge:_ a search-engine build. // "Your ranking pipeline is the relevance core we are rebuilding."

**42. Recommendation, ranking, and ads** _Weekend build:_ a recommender toy, a bandit experiment, a feature-store sketch; often internal, so qualify on history too. _Phrasings:_ `recommendation systems, candidate generation, ranking` · `feature stores, real-time features` · `multi-armed bandits, online learning` · `CTR prediction, embeddings at scale` · `two-tower retrieval models`. _Widen with:_ `pastCompanies=<a-recsys-heavy-company>` · `techs=python,scala` · adjacent: ML infra, search. _Surfaces a real one:_ a ranking repo is a bonus; recsys tenure is the evidence when public code is thin. _Tell / Bridge:_ ranking repo or recsys tenure. // "Your candidate-generation design is exactly our ranking stack."

**43. Data visualization and interactive graphics** _Weekend build:_ a charting library, a D3 explorable, a WebGL data explorer. _Phrasings:_ `data visualization, D3, custom charts` · `interactive explorable explanations` · `WebGL data rendering, large datasets` · `graph and network visualization, force layouts` · `dashboards from scratch, rendering performance`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=typescript,javascript` · adjacent: frontend craft, creative coding. _Surfaces a real one:_ custom viz or explorables, not a charting-library config. _Tell / Bridge:_ a viz library or explorable. // "Your force-layout renderer is exactly our graph-explorer need."

### Interest and archetype lenses (the weekend tell)

**44. Developer-experience obsessives** _Weekend build:_ elaborate dotfiles that grew into real tools, a CLI they made for themselves, editor plugins. _Phrasings:_ `developer experience tooling, cli ergonomics` · `editor plugins, neovim, vscode extensions` · `shell tooling, terminal UIs, TUI libraries` · `productivity tools built for myself` · `config and dotfiles turned into libraries`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=go,rust,lua` · adjacent: build tooling (entry 10). _Surfaces a real one:_ small sharp tools that other developers adopted; a habit of removing friction. _Tell / Bridge:_ a self-made tool with users. // "Your TUI library is the kind of internal tooling taste we want on the team."

**45. Homelab, self-hosting, and privacy** _Weekend build:_ a self-hosted stack, a home-automation setup, a privacy-preserving service. _Phrasings:_ `self-hosting, home lab, docker compose stacks` · `home automation, home assistant integrations` · `privacy-preserving tools, local-only` · `personal cloud, sync, backup systems` · `network tooling, dns, vpn, wireguard`. _Widen with:_ `orgs=<orgs behind the canonical projects>` · `techs=python,go` · adjacent: infra, local-first, security. _Surfaces a real one:_ real self-hosted projects and integrations; a systems-thinking hobbyist. _Tell / Bridge:_ a homelab or self-host repo. // "Your self-hosted sync stack shows the ops instincts we need."

**46. Retro, emulators, and low-level hobbyists** _Weekend build:_ an emulator for an old console, a chip-8 interpreter, a demoscene intro. _Phrasings:_ `emulator, cpu emulation, cycle-accurate` · `chip-8, gameboy, NES emulator` · `demoscene, size-coding, intros` · `assembly, hand-optimized routines` · `reverse engineering old hardware`. _Widen with:_ `techs=c,cpp,rust,assembly` · adjacent: compilers, graphics, kernel. _Surfaces a real one:_ an emulator or low-level project finished for the love of it; deep patience. _Tell / Bridge:_ an emulator or low-level repo. // "Your cycle-accurate emulator shows the systems depth our core needs."

**47. Niche open-source maintainers** _Weekend build:_ they maintain the one library everyone in a narrow space depends on. _Phrasings:_ run a repo-analog seed instead: deep-research a canonical repo in the niche, read its notable contributors, then `similar?login=` the strongest. Also `q=<the niche problem the library solves>`. _Widen with:_ `orgs=<the library's org>` · `similar?login=<the maintainer>` · adjacent: whatever the library serves. _Surfaces a real one:_ sustained maintenance of a depended-on project; respect from serious builders. _Tell / Bridge:_ they own the niche. // "You maintain `<library>`, which our stack depends on; we would rather have you inside." _Note:_ apply Q1 and Q2 hard here. Some maintainers are unreachable celebrities; target the gettable band and the early-but-serious maintainers.

**48. Hardware hackers and makers** _Weekend build:_ a PCB they designed, an Arduino or Raspberry Pi build, a 3D-printed robot. _Phrasings:_ `PCB design, KiCad, custom hardware` · `arduino and raspberry pi projects, real builds` · `3D printing, CAD, custom mechanisms` · `microcontroller projects, sensors, actuators` · `hardware plus firmware integration`. _Widen with:_ `techs=cpp,python` · adjacent: embedded, robotics, IoT. _Surfaces a real one:_ hardware plus code together; build logs and schematics. _Tell / Bridge:_ a real hardware build. // "Your PCB-plus-firmware project is exactly the hardware-software bridge we need."

**49. Early adopters of a new language** _Weekend build:_ they picked up Rust, Zig, Gleam, or Roc early and built real things while it was still rough. _Phrasings:_ `<language> library, early ecosystem` · `<language> from scratch project, systems` · `porting to <language>, idiomatic` · `<language> tooling and libraries` · `experiments in <language>`. _Widen with:_ `techs=<language>` · `lang=<language>` · `orgs=<language's core org>` · adjacent: whatever they build. _Surfaces a real one:_ real projects in the language while it was young; curiosity and a high learning slope. _Tell / Bridge:_ early real work in the language. // "You were building serious Zig before it was easy; that curiosity is what we hire for."

**50. Scratch-their-own-itch automators** _Weekend build:_ bots, scrapers, glue tools, automations that solve a problem they personally had. _Phrasings:_ `automation tools, bots, scrapers` · `personal productivity automation` · `glue code, integrations, webhooks` · `scripting, workflow automation` · `built to solve my own problem`. _Widen with:_ `techs=python,typescript` · adjacent: DX obsessives (44), tooling. _Surfaces a real one:_ a pattern of pragmatic tools that shipped and got used, even if small; product instinct. _Tell / Bridge:_ a body of practical, used tools. // "Your habit of shipping small tools that people actually use is the product sense we want."