The Goblin Reactor silkie goblin

Systems performance consulting

Hard systems projects, taken all the way to production.

Goblin Reactor diagnoses, designs, builds, tests, and rolls out difficult performance and infrastructure systems—with measured results in memory, latency, throughput, reliability, and cost.

Send a short technical intake. Qualified problems receive a complimentary 20-minute fit call.

C++, Python, SIMD, market data, caching, search, matching, and performance-critical backend infrastructure.

The Delivery Gap

More code does not guarantee a finished system.

Some teams lack the time or specialist capacity to build the system at all. Others can generate implementation quickly but remain stuck on architecture, integration, correctness, migration, performance, and production rollout.

Goblin Reactor takes ownership of the hard technical path: establish what is true, design the system, build or direct the implementation, test the ugly cases, manage the rollout, and measure the result.

What Goblin Reactor Fixes

When a difficult systems problem has become a business problem.

Goblin Reactor works in the uncomfortable layer where software meets the machine—and where promising projects become expensive operational problems. That includes architecture, data layout, cache behavior, vectorization, memory pressure, serialization, storage tiers, migration, rollout, and the difference between code that works in isolation and a system that keeps working under load.

  • Data and compute pipelines that are too slow to scale.
  • Cache layers, Redis clusters, and object-heavy services burning too much RAM.
  • Matching, search, analytics, or market-data systems that fell over at real volume.
  • Hardware migrations where ARM, LoongArch, POWER, or SIMD dispatch matters.
  • Difficult infrastructure projects stalled between prototype and production.

Services

Examples of problems Goblin Reactor is built to handle.

01

Systems Rescue and Delivery

Diagnose the real constraint, establish a production path, and deliver a working result for systems that are slow, expensive, unreliable, stalled, or too technically awkward for ordinary consulting.

  • Performance and architecture diagnosis
  • Production implementation and technical project ownership
  • Migration, rollout, and measurable acceptance criteria
  • Rewrite, patch, or leave-it-alone recommendations

02

Memory-Efficient Infrastructure

Replace pointer-heavy, general-purpose infrastructure with compact workload-specific designs that keep behavior while wasting less RAM.

  • Redis-like and cache-heavy systems
  • Python object graph reduction
  • Storage tiers pretending to be RAM

03

SIMD and Hardware Acceleration

Scalar reference validation, vectorized kernels, runtime dispatch, benchmark harnesses, and performance regression tests.

  • x86 AVX2 and AVX-512
  • ARM NEON and SVE
  • LoongArch LASX/LSX and other unusual targets

04

Market Data Systems

Infrastructure for tick data, replay, parsers, latency-aware research, real-time indicators, and execution-adjacent tooling.

  • Historical tick parsing and storage
  • Replay systems and lookahead-bias avoidance
  • Market-data feeds and simulators

About

Adam DePrince builds the systems behind Goblin Reactor.

Goblin Reactor is Adam DePrince, a systems and performance specialist who has been building production software since 1989, when he wrote Pascal for a pharmaceutical manufacturer while still in high school. Since then his work has spanned startups, big tech, and the stranger corners of high-performance and market-data infrastructure: 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 projects below are his—and they are the proof behind the consulting offer. Based in Vermont; available for remote work.

Proof From Open Source

The open-source work is the proof. The consulting offer is how teams bring that capability into their own systems.

Goblin Core

Redis-compatible sorted sets and hashes built on compact Swiss-table indexes and packed arenas. In parity benchmarks, Goblin Core is the leanest engine tested and beats every tested Redis-compatible server across measured sorted-set operations, while also leading the hash memory comparison.

Goblin Store

A large-object cache and HTTP object server that uses RAM, SSD, and hard drives together to replace expensive RAM with SSD and expensive SSD capacity with hard-drive capacity. For 256 KiB-8 MiB objects, Goblin Store uses 7.4x less RAM at memcache latency, which means substantially lower costs.

stride-align

SIMD-accelerated sequence alignment and fuzzy matching with Unicode/CJK support and runtime dispatch across multiple CPU families.

massive-speedup

Massive.com flatfile parsing and market microstructure simulation, iterating flatfiles faster than Python gzip and csv.

fast-kalman

C++ and Python Kalman filters running dramatically faster than OpenCV on small fixed-size filters used in streaming workloads.

NumPy LoongArch LASX

Architecture-specific acceleration work enabling NumPy's 256-bit Loongson SIMD path and extracting speed from an unfamiliar stack.

Delivery

From difficult problem to measured result.

  1. 01

    Establish reality

    Goals, stakeholders, constraints, profiles, traces, benchmarks, failure evidence, and business impact.

  2. 02

    Design the production path

    Architecture, ownership, milestones, interfaces, risks, migration, and acceptance criteria.

  3. 03

    Build the system

    Direct implementation or technical direction of AI and human contributors.

  4. 04

    Test the ugly cases

    Correctness, failure recovery, concurrency, compatibility, load, and performance regression testing.

  5. 05

    Roll out and measure

    Production migration, operational validation, and comparison against the agreed result.

Engagements may cover one stage or the entire path.

Technical Intake

Tell me what is slow, expensive, unreliable, or failing.

A few concrete details are enough. I am looking for the shape of the system, the evidence already available, the business cost, and whether the people who can act on the answer are involved.

What happens next

I review serious submissions personally. When the problem and evidence look like a fit, I may reply with an invitation to a complimentary 20-minute call. The scheduling link is sent only after intake review.

No files are uploaded; link to evidence or describe what is available. If the form is unavailable, email adam@goblinreactor.com.

Engagements

Qualification first. Paid analysis when the problem merits it.

If Goblin Reactor does not deliver the documented profile, headroom analysis, and prioritized recommendation, the audit fee is refunded.

Engagement Structure

Engagements are scoped around the problem and expected business value.

Work may begin with a paid technical scoping session or focused performance audit, followed by a defined implementation engagement when the evidence supports it. Smaller diagnostic or prototype engagements are available when they are the right first step.

Goblin Reactor does not provide open-ended staff augmentation, emergency on-call support, or commodity hourly development.

Good Fits

Performance-critical systems and difficult infrastructure projects.

Call Goblin Reactor for

  • Fintech and market-data infrastructure
  • Cloud bills driven by memory-heavy services
  • Redis, memcached, search, dedupe, and entity matching at scale
  • AI/data preprocessing bottlenecks
  • ARM, LoongArch, or nonstandard hardware ports
  • Hard infrastructure projects stalled between prototype and production
  • AI-assisted implementations that need senior architecture, validation, integration, or rollout ownership

Probably not for

  • Ordinary CRUD applications
  • Brochure websites
  • Generic cloud migrations
  • Trading strategies
  • Just another React developer slot

Confidentiality and development environment

Client code, data, credentials, and other confidential material are handled under written confidentiality and security terms.

The development environment—including any AI tools, data-retention settings, and dedicated-hardware requirements—is agreed before work begins.

I do not submit client material to services that use it for model training. Where client policy requires, work can be performed on dedicated hardware without external model access.

Contact

If your system is too slow, too expensive, unreliable, stalled, or too weird for ordinary consulting, send a note.

Start with the short technical intake. Qualified problems may receive a complimentary 20-minute fit call. Available for remote consulting from Vermont.