Open Source

A GPT-2 serving engine in PyTorch with naive, static and continuous batching behind an OpenAI-style API; continuous batching gives 11.7x the naive throughput on a laptop GPU.

A red-team harness that runs 43 inert prompt-injection, secret-exfiltration and tool-abuse attacks, mapped to the OWASP LLM Top 10, against a sample retrieval agent with fake tools, and fails CI when the hardened agent’s attack success rate regresses.

• ai-safety
• guardrails
• llm-evaluation
• llm-security

Scheduled input-drift checks for ML models: a stored reference window per feature, PSI with KS or chi-square tests implemented in numpy and verified against SciPy, and a per-feature verdict that says why.

• chi-square
• data-drift
• kolmogorov-smirnov
• mlops

QLoRA vs prompting, measured: a 4-bit Qwen2.5-0.5B adapter trained in 13 minutes on a 6 GB laptop GPU reaches 91% on BANKING77, against 26% for few-shot prompting, at 20 times lower latency.

• bitsandbytes
• fine-tuning
• intent-classification
• llm-evaluation

The ‘recommended for you’ problem, step one: a two-tower model and FAISS narrow thousands of movies to the best 500 in under a millisecond, beating popularity on MovieLens 1M (recall@10 0.083 vs 0.048).

• faiss
• movielens-1m
• python
• pytorch

Finds accessibility problems on a web page automatically: Playwright captures it at phone and desktop sizes, axe-core checks WCAG A and AA rules, and each finding points to the element and viewport.

• accessibility
• axe-core
• playwright
• python

Catch malicious files with machine learning, then test how easily an attacker can fool it, because they will try.

• adversarial-ml
• lightgbm
• machine-learning
• malware-detection

Understand how ChatGPT works by building it from scratch, starting at the bottom: a NumPy autograd engine with every gradient checked numerically, and a byte-level BPE tokenizer trained on TinyStories.

• deep-learning
• from-scratch
• llm
• numpy

Quantization measured on a 6 GB laptop GPU: a DistilBERT classifier as an fp32 baseline, then fp16, int8 and int4 (own round-to-nearest and bitsandbytes), with accuracy, flipped predictions, memory, latency and energy per variant.

• bitsandbytes
• inference
• int4
• int8

Data-parallel training of a 4.8M-parameter GPT on 1, 2 and 4 ranks: hand-written DDP with a bucketed ring all-reduce, checked against single-process training and PyTorch DDP.

A gRPC price-ticker in Go with unary, server-streaming and bidirectional endpoints, and a Buf contract gate that lints the protobuf API and refuses breaking changes in CI.

• api-design
• bidirectional-streaming
• breaking-change-detection
• buf

k6 load, stress, spike and soak tests against a capped Go sample service, with every window checked by the USE method (utilization, saturation, errors) to find the breaking point and the resource behind it.

• capacity-planning
• golang
• k6
• load-testing

The database no longer fits one machine, step one: copy a tenant to another shard while it keeps taking writes, with PostgreSQL logical replication keeping the copy in sync and checksums proving both sides match.

• database-migrations
• go
• logical-replication
• multi-tenancy

Fan-out on write for a social feed in Go: a power-law follow graph with million-follower accounts, posts stored once, and post IDs pushed to every follower’s timeline; the Kafka and Valkey path’s first CI run is pending.

Hybrid search on PostgreSQL: full-text and pgvector results merged with reciprocal rank fusion, embeddings from a pure-Go MiniLM encoder checked against ONNX Runtime, every mode scored on judged queries.

• embeddings
• golang
• hybrid-search
• information-retrieval

Live multiplayer text editing over WebSockets on top of a CRDT: authenticated rooms where every client converges to the same text, with guards against forged edits, floods and oversized messages.

• collaboration
• crdt
• nodejs
• real-time

Keeps an order, its payment and its stock consistent across services, and undoes them cleanly when one step fails.

• java
• kafka
• microservices
• saga-pattern

One customer must never see another’s data: multi-tenant isolation with a test suite that actively tries to break in.

• multi-tenancy
• nestjs
• postgresql
• row-level-security

Flash-sale stock admission in Java 21: stock preloaded into Valkey, a gateway that sheds load with a rate limit, an in-flight cap and capped queue tokens, and one atomic Lua script per purchase so stock is never oversold.

Contract-first API workflow: the API is designed in TypeSpec, compiled to OpenAPI 3.1, and a Spectral style guide (naming, cursor pagination, RFC 9457 errors) gates every change in CI.

• api-design
• api-linting
• ci
• contract-first

A recursive DNS resolver and an HTTP/1.1 server written from the wire format up in Java, tested against real root servers and curl, Python and Node.js clients.

Three same-Big-O experiments (memory access order, branches, boxing) in Java, Python and Node.js, each with a hypothesis written before the run, measured with JMH, pyperf and mitata, and judged on the range across forks.

• benchmarking
• branch-prediction
• cpu-cache
• jmh

One money and date-range library in Java, Python and JavaScript held to a single 74-row spec, with 20 realistic seeded bugs each proven to change a result, as the base for comparing testing techniques.

• java
• javascript
• mutation-testing
• polyglot

The same allocation-heavy workload measured in Java 21, Node.js 24 and CPython, plus Java escape-analysis cases where a one-line change takes allocation from 24 to 0 bytes per operation, proved from C2’s own compilation log.

• cpython
• escape-analysis
• garbage-collection
• jit-compiler

Twelve classic system-design problems turned into numbers: every estimate is computed from stated assumptions, identically in JavaScript and Java, so a what-if is one flag.

• architecture
• capacity-planning
• distributed-systems
• java

One test suite, three languages: a min-heap, a hash map and an LRU cache written in Java, Python and JavaScript, all replaying the same language-neutral test vectors to prove they behave identically.

• algorithms
• benchmarks
• data-structures
• java

CPU scheduling simulator in TypeScript that runs in a Web Worker: five algorithms on the same traces with waiting time, turnaround and fairness, checked against textbook results and an independent Python reference.

• cpu-scheduling
• education
• operating-systems
• ostep

The same five concurrency problems solved in Java, Python and JavaScript and checked against the same invariants, to show how each runtime really schedules work.

• asyncio
• concurrency
• event-loop
• java

Stops 'it passed the sample input' from meaning 'it's correct': classic algorithms in three languages, each with a correctness argument and its real running time measured.

• algorithms
• complexity-analysis
• dynamic-programming
• graph-algorithms

The design writing behind the code: RFC and ADR templates, a review process, an index of every project’s design documents, and a checker that fails CI on missing sections or leftover placeholders.

• architecture-decision-records
• design-docs
• engineering-leadership
• postmortems

Treats security alerts like software: detections written in Sigma, tested against real attack logs, deployed through CI.

• blue-team
• detection-engineering
• mitre-attack
• python

Times seeded Star Schema Benchmark and TPC-H queries cold and hot on DuckDB with medians, versions and answer checks; ClickHouse, Doris and StarRocks adapters and CI job written, first CI run pending.

Three idempotent write patterns (MERGE on natural keys, atomic partition overwrite, dedup-key insert) and a run ledger committed with the data, tested on DuckDB and SQLite through crashes, killed processes and reruns.

• backfill
• data-engineering
• data-quality
• duckdb

An Avro schema registry with the Confluent REST paths that assigns global IDs and versions and rejects breaking changes under backward, forward, full and transitive modes, naming the field and rule.

• api
• avro
• data-contracts
• kafka

dbt and DuckDB warehouse on pinned NYC taxi data: staging, intermediate and star-schema marts with contracts, and every raw record either loaded or rejected with a reason.

• analytics-engineering
• data-quality
• data-warehouse
• dbt

Demystifies why analytics databases are fast: a readable SQL engine on Apache Arrow with an optimizer and a vectorized executor, its results and speed checked against DuckDB.

• apache-arrow
• duckdb
• python
• query-optimizer

Real-time ML features from a click stream with event-time windows, where late and out-of-order events are handled explicitly; a reference engine defines the right answer and the PyFlink job is checked against it.

• apache-flink
• event-time
• feature-engineering
• kafka

PII found at ingestion with Presidio and checksum validators, then replaced by FF3-1 format-preserving tokens that keep length, separators and check digits, so joins still work and nothing leaks. Topics: pii data-privacy tokenization fo

• data-engineering
• data-privacy
• format-preserving-encryption
• gdpr

OpenLineage events from dbt and plain Python scripts, checked against the official schemas, plus Spark, Airflow and Marquez integrations and a typed TypeScript client for the Marquez API; the integrations’ first CI run is pending.

Stops an upstream change silently breaking every downstream dashboard: producers publish a contract and CI blocks breaking changes.

• continuous-integration
• data-contracts
• data-engineering
• data-quality

Fresh analytics without hammering the production database, step one: Debezium streams every Postgres insert, update and delete into Kafka as Avro events, checked end to end in CI with about 270 ms lag.

• apache-iceberg
• change-data-capture
• debezium
• kafka

About: Every pull request gets its own kind cluster in CI: the PR’s images are built and loaded, a Helm chart is installed with anonymized seed data and checked by helm test, and the cluster is deleted.

• ci-cd
• ephemeral-environments
• github-actions
• golang

eBPF programs that time run-queue delay, block I/O and fsync latency, with log2 histograms built in kernel BPF maps and a Go CLI to check tracepoint layouts and render them.

A backup you never tested is not a backup: an operator that backs up Postgres and proves each backup can actually be restored.

• backup
• disaster-recovery
• go
• kubebuilder

Six Rego guardrails (public S3 buckets, open admin and database ports, public or unencrypted databases, missing tags) tested with opa test and enforced by conftest on real terraform plan JSON in CI.

• aws
• conftest
• devsecops
• github-actions

Stops a vulnerable image reaching production: actions pinned by commit SHA, and every image smoke-tested, described by an SBOM and scanned, with critical CVEs failing the build.

• devsecops
• go
• sbom
• sigstore

A warm standby in a second AWS region, built from the same Terraform module as the primary and checked without an AWS account: mocked terraform tests, a parity check that keeps the regions identical, and the standby’s cost (54% of the primary).

• aurora
• aws
• disaster-recovery
• ecs-fargate

One Backstage form creates a ready-to-build service in Go, Node.js or Python: code skeleton, CI, Dockerfile, catalog entry and docs, with the template rendered and tested locally.

• backstage
• nunjucks
• platform-engineering
• software-templates

Go, Python and Node.js services linked by HTTP and a queue, with an end-to-end test proving each order is one OpenTelemetry trace via W3C traceparent, and that it splits without header propagation.

• distributed-tracing
• golang
• nodejs
• observability

Flagger canary releases on the Gateway API: traffic moves to a new image in 5-10-20-40-60-80% steps, with the configuration checked against Flagger’s schema and house rules on every push and a real rollout on kind in CI.

• canary-release
• devops
• envoy-gateway
• flagger

YAML chaos experiment plans with a falsifiable hypothesis, blast radius and abort conditions, checked by a schema and safety rules and sealed before the game day starts.

Deterministic simulation testing in Go: services written against time, network, disk and randomness interfaces run in a single-threaded simulator where one seed decides every event, so any failure replays exactly.

• deterministic-simulation-testing
• distributed-systems
• fault-injection
• golang

SWIM failure detection in Go: indirect pings and refutable suspicion, tested in a seeded network simulator and over UDP on loopback.

How a database keeps working when a server dies: a sharded, replicated key-value store that stays correct through crashes and network splits.

• consensus
• go
• key-value-store
• linearizability

Why databases like Cassandra stay fast while writing constantly: a storage engine built to survive a crash without losing a single acknowledged write.

• database
• go
• key-value-store
• lsm-tree

Percolator-style distributed transactions in Go: a hybrid timestamp oracle, snapshot-isolated reads and a prewrite phase that locks every key under a primary.

HyperLogLog and Count-Min Sketch in plain Java 21 that count unique and top items in kilobytes, with the observed error tested against the theoretical bounds.

• cardinality-estimation
• count-min-sketch
• heavy-hitters
• hyperloglog

A small typed language for pricing and eligibility rules: a hand-written parser and type checker that report every mistake at once, with its exact position and a hint, before the rule ships.

• compiler
• dsl
• java
• parser

Five Twitter production cache traces replayed through FIFO, LRU, LFU, ARC and W-TinyLFU in Java 21, with every policy checked against a brute-force model before its hit rates are compared.

• arc-cache
• cache-eviction
• caching
• count-min-sketch

Lets many people edit one document at once, even offline, and never lose an edit: the engine behind Google-Docs-style editing.

• collaborative-editing
• crdt
• distributed-systems
• local-first