HPC and heterogeneous compute
GPU workloads and multi-node performance, including clusters where the devices no longer match each other.
We solve deep tech and specialised systems end to end.
Some problems don't get easier when you add engineers. The hard part is the system itself, where correctness, performance or physics rules out the obvious approach. Those are the ones we take.
Scope · build · verify · handover. You own every deliverable.
What we work with
Compilers, optimisation and infrastructure.
Applied to physics compilers, GPU and HPC workloads, verified microkernels, and control systems where being wrong has consequences. Six areas, because these are the ones we can take to the end.
Formal verification and microkernels
Minimal trusted bases and provable isolation for systems where being wrong has consequences. We are an seL4 tech partner.
Agentic systems
Autonomous control loops for hardware, toolchains and regulated domains, where the loop has to be auditable after the fact.
Optimised compute pipelines
Custom backends, optimisation pipelines and compiler passes for workloads the general-purpose toolchain handles badly.
On-prem deployment and maintenance
ML models served inside air-gapped environments, and kept running there after we hand over.
Custom tooling for network, GPU and compiler
Instrumentation and toolchains built to fit the problem. Triton kernels, custom network protocols, whatever the workload needs.
Apps and product engineering
The product layer on top of the hard part. Web, iOS and Android, built native where it matters and cross-platform where it doesn't.
Developer infrastructure and SDKs
Multi-language code generation, SDK tooling and the internal platforms your own engineers build against every day.
Product strategy
What to build, in what order, and what to cut. Useful when the technical constraint and the product decision are the same decision.
How we work
Four phases. Each one leaves you something.
Every phase has to put something in your hands before the next one starts. That rules out the long quiet middle where a project looks fine right up until the week it was due.
Book a scoping callShort and fixed, priced before it starts. We read the code, talk to whoever hits the problem, and reproduce it ourselves. If the honest answer is that you don't need us, that's what the plan says.
You get: A problem statement you could hand to anyone
Milestones with working artifacts rather than status reports. Each one lands in your repo, on your infrastructure, running. You can pull the branch and try it that afternoon instead of waiting for a demo.
You get: Something that runs, at every milestone
Tests, benchmarks, proofs, whatever the work calls for. On a GPU cluster that means reproducible timings across node configurations. On a verified kernel it means the proof obligations actually discharge.
You get: Numbers you can check yourself, without us
Reproducible builds, documentation, code and whatever artifacts you asked for. We walk your team through it while we're still on the clock, so the questions get answered by the people who wrote the code.
You get: A repo your team runs without us
References
Problems that had no obvious approach.
Current engagements, described in full. Clients stay unnamed until each one agrees to be, because naming and publication are settled before work starts.
Our numbers, and why we build
12+ yrs
Combined experience
3
Active engagements
100%
Deliverables you own
1 day
Typical reply
We take the work where the hard part is the system, and we stay on it from defining the problem to code your team runs without us.
The Hopline founders
Two founders · 12+ years combined
Next step
A scoping call to define the problem.
Tell us what is not working and we'll tell you whether it's the kind of problem we take. We reply within a day, and it's one of the founders reading it.
Prefer email? contact@hopline.co, or tell us more on the
contact page.