Application runtimes
Preserve useful APIs while moving measured hot paths out of interpreter and framework machinery.
C++ / Python / performance engineering
Adam DePrince.
I make software faster where it actually matters.
I work across runtimes, databases, storage, networks, algorithms, and hardware. I profile complete systems, move the right work into native code, and publish measurements with enough context to reproduce.
The projects range from a C++ port of Django and compact data servers to SIMD libraries, unusual CPU architectures, low-latency transports, and a complete electronic-trading reference system.
Latest project / cppdjango
Django 6.0.7.
Ported to C++.
cppdjango keeps the
familiar Django API and normal import django surface,
while moving measured PostgreSQL ORM terminals into native code.
Across a balanced suite of point selects, ordered IN queries, and point updates, the framework-side ORM work is 436% faster and uses 81.4% less CPU than stock Django 6.0.7. The database did not become faster, and the project does not claim that every Django API did.
One complete application
The electronic-trading reference system
Trading is one substantial application of the performance work, not the whole portfolio. The open-source reference system joins causal historical replay, native market-data ingestion, streaming analytics, low-latency fan-out, position-intent routing, broker execution, and operator control.
It uses Massive and Alpaca for research and intraday strategies and is not presented as an exchange-colocated HFT platform. The dedicated page explains both the complete architecture and the faster machinery underneath it.
Explore the complete trading-system stackThe work crosses layers
Performance across the whole machine
The useful optimization is often outside the function that first appears slow. I follow the cost through language boundaries, allocators, memory, operating systems, networks, and hardware.
Data structures
Compact layouts, allocation behavior, cache traffic, NUMA placement, and algorithms chosen for the real workload.
Storage hierarchy
Use RAM for latency-sensitive heads, SSD for warm data, and disks for capacity without pretending every byte is equally urgent.
Transport
Shared memory, RDMA, libfabric/EFA, XLIO, kernel bypass, and ordinary TCP when ordinary TCP is sufficient.
SIMD and architectures
Vectorized kernels and runtime dispatch across x86, Arm, LoongArch, RISC-V, and other machines the mainstream often neglects.
Measurement
CPU accounting, latency distributions, tail analysis, controlled benchmarks, and artifacts that let other people inspect the claim.
Selected open source
Systems built around a measured bottleneck
These projects are not organized around one industry. Each starts with a concrete cost in CPU, memory, storage, or latency and makes the evidence part of the software.
Data structures and transport
Goblin Core
Problem Redis-compatible operations and interprocess messaging pay for memory layout, parsing, and transport on every request.
Work Compact C++23 structures with RESP and SBE over shared-memory rings, one-sided RDMA, libfabric/EFA, XLIO, Unix sockets, and TCP.
Measured A complete compact HSET or ZADD request/reply over the SBE shared ring takes about 220 ns on pinned neighboring Threadripper PRO 5995WX cores.
Why it matters It is both a useful server and a laboratory for memory traffic, protocol overhead, and network paths.
Large-object storage
Goblin Store
Problem Keeping every byte of a large object in RAM wastes expensive memory even when the network cannot reach the tail yet.
Work A Memcached-compatible server keeps object heads in locked memory and streams later bytes asynchronously from SSD or HDD.
Evidence Published comparisons include Memcached and extstore with workload, latency, memory, and storage-cost context.
SIMD sequence algorithms
stride-align
Problem Alignment and distance algorithms are expensive inner loops with very different instruction sets across CPUs.
Work Smith-Waterman, Needleman-Wunsch, edit distance, phonetics, and time-series distance for C++ and Python across several architecture families.
Evidence The benchmark suite publishes backend, scoring, width, workload, and CPU context rather than one universal speedup.
Streaming analytics
RTTA
Problem Incremental indicators and online models should update state without rebuilding arrays or paying dataframe overhead per event.
Work 319 public causal algorithms behind a consistent C++23 and Python streaming API.
Measured Published runs cover 247 algorithms each; the three per-CPU medians average 57.7 ns for state-only advance and 77.4 ns with a Python result.
LoongArch optimization
DragonArray
Problem Useful hardware remains slow when upstream packages stop at generic code or narrower vector extensions.
Work Installable LoongArch wheels, NumPy LASX work, SIMD transcendental functions, and a BLAKE3 LoongArch port.
Evidence Patches and benchmarks are published together so architecture support is something users can run, not a slide.
Small-state estimation
fast-kalman
Problem Tiny state-space models should not pay dynamic-matrix or per-tick Python overhead.
Work Fixed-size C++23 Kalman variants, direct Python bindings, and batched updates with irregular time and observation variance.
Measured The published batched two-state, one-observation linear case runs at about 43 ns per measurement on its documented test machine.
External sorting
bsort
Problem Fixed-record data sets larger than RAM turn locality and cache behavior into the algorithm.
Work A C++ and Python external sorter designed around local access, predictable records, and LRU-friendly behavior.
History The experiment became the technical basis for a startup and remains available as open source.
More systems work
Experiments, ports, and useful tools
Some work becomes a server or library. Some work exists to answer a narrow systems question. Both belong here when the implementation and evidence are useful.
Interpreter internals
CPython SIMD
Runtime SIMD experiments for codecs, text, bytes, JSON, CSV, URLs, and hash tables.Numerical computing
NumPy LASX
A proof-of-concept 256-bit LASX port for Loongson systems.Hostile networks
mosh patches
Agent, socket, SOCKS, X11, and stream forwarding with FEC bulk transfer.Packet-path analysis
Latency Lab
Replay captures through rate, framing, queueing, and compression models with complete latency distributions.Incremental graph search
negcycle
SIMD Bellman-Ford paths for exact currency-cycle analysis after individual quote changes.Under development
Goblin Cannon
A long-haul modem design tested only in its unit-test environment; no field result is claimed.Procurement and classification
Search tools
NAICS and CPV semantic code finders.Small experiments
Useful toys
Sloppy Resume, R820 notes, and Bluesky Pulse.The work has a history
Why Adam
I have built production software since 1989: quantitative and market-data systems at Quantlab and Massive.com, financial data at scale at S&P Global, and large-scale engineering at Google and Amazon.
The open-source work continues that path in public. I build the implementation, the benchmark harness, and the evidence needed to explain what improved, what did not, and why.
Performance engineering is not a bag of tricks. It is careful accounting across the complete system, followed by changing the layer that actually owns the cost.
Goblin Reactor
Bring me a difficult systems problem
I build open systems that demonstrate the capability. Goblin Reactor brings that capability into client systems: application runtimes, databases, memory, storage, networking, native code, and production behavior.
Tell me what is slowf"{given_name.lower()}.{family_name.lower()}@gmail.com"- Phone
f'{2**8}-{2*3**2*37}-{13*101}'- GitHub
- github.com/adamdeprince
- Field notes
- adamdeprince.com/blog