Performance engineer for AI and backend systems

I find out why software is slow,
and make it fast.

Faster responses, fewer GPUs, lower cloud bills. I find what's slow, prove it, and fix it.

ContactHow it worksOpen to contract work.

Measured on an RTX 5090 GPUllama.cpp PR #30077 (opens in a new tab)

before

Summarize the key risks in this 40-page contract.

after

Summarize the key risks in this 40-page contract.

Up to 2.1x faster AI replies

Long chats answer about twice as fast without new hardware.

The llama.cpp and vLLM gains are fixes to the engines themselves, so they speed up everyone who runs them. Your own stack has inefficiencies of its own on top of that, and that's where I start.

I work inside compilers and language runtimes too. Roblox's Luau team has merged 7 of my fixes to its native code generator, register allocator and type checker. Wasmtime's maintainers merged another (opens in a new tab), to its x64 code generator, and credited me as the reporter of a security advisory (opens in a new tab). See the Luau fixes (opens in a new tab)

Contributed to
  • LLVM
  • vLLM
  • llama.cpp
  • LuauRoblox
  • WasmtimeBytecode Alliance
  • wabtWebAssembly
  • zstdMeta
  • mruby
  • wgpu
  • tt-metalTenstorrent

Problems I solve

AI models that run slower than the hardware allows

I profile inference engines such as llama.cpp and vLLM down to the GPU kernels, and fix the bottleneck.

Up to 2.1x faster decoding at 32k context in llama.cpp on an RTX 5090 with a q4_0 cache and CUDA 12.8 (fix in review).

Backends and databases that don't keep up

Slow queries, data that keeps growing, and migrations that cannot lose anything on the way.

After I rewrote Rolantir's hourly chart queries, they took 3 to 8 ms instead of 400 to 900 ms, measured on production. The database move kept the full history.

A cloud or GPU bill growing faster than your users

I profile where the compute goes, find the work that should not be there, and fix it, so the same traffic needs less hardware.

In my sample audit, the same document traffic fit on 3 GPUs instead of 5 after one setting change.

C, C++ or Rust code that reads untrusted input

I sweep one parser, codec, runtime or VM for the bugs crafted input can trigger, and deliver each one with a reproducer and a fix.

Wasmtime's maintainers credited me as the reporter of a security advisory, and wabt and mruby merged my fixes for memory sizes and string lengths that wrapped.

Selected work

Rolantir

co-founded

Analytics for the Roblox platform. It tracks 1M+ games in a 24.5 GB live database. I started it from the backend, crawler and game tracker, and moved it live from SQLite to PostgreSQL with TimescaleDB without losing history.

50x faster chart queriesmeasured on production
9.5x smaller history35 GB stored in 3.7 GB
before
400 to 900 ms
after
3 to 8 ms
Hourly chart query time, measured on production, June 2026

Read the caserolantir.dev (beta) (opens in a new tab)

llama.cpp

upstream fix

A fix in llama.cpp itself for long AI conversations on an RTX 5090. The compiler kept a small value in slow memory, and I changed how the kernel reads it.

2.1x faster decodingat 32k context
About 10 lines changedin two functions
before
65.1 tok/s
after
134.4 tok/s
Decode speed at 32k tokens of context, RTX 5090, CUDA 12.8.1

Read the casePR #30077 (open) (opens in a new tab)

Luau compiler and runtime

7 merged

Luau is the language behind Roblox. Its maintainers merged 7 of my fixes in 2026, to the native code generator, register allocator and type checker.

All merged pull requests (opens in a new tab)

Writing

How I found two of these slowdowns, step by step, with the numbers and the dead ends.

All writing

Start with a two-week investigation

One fixed price to learn what's slow, why, and what fixing it is worth. Then I fix it.

1 Investigation

2 weeks
Introductory, first few clients

€3,000/ $3,500

List price €5,000 / $6,000

One workload in one environment

  1. You send the slow partTell me what's slow and where it runs. Then we talk it through in a short call.
  2. I find the causeI measure a baseline and trace the slowdown to its cause, at whatever layer it sits.
  3. You get the reportRanked fixes, each with its expected gain, its cost and how sure I am.
  • A measured baseline
  • Causes with evidence
  • Ranked fixes
  • A fixed quote for the fix
  • Up to 2 hours of calls

2 The fix

Priced separately

Fixed quotefrom the report

You see the price before you decide.

  1. I fix itAt the fixed price from the report, agreed in writing before I start.
  2. You review the pull requestsEvery change goes through your CI, and nothing ships without your sign-off.
  3. I measure the resultAgainst the same baseline as the report, so you see what changed.

Or your team fixes it from the report. It's written so your engineers can act on it.

Rented GPU time is billed at cost, with your approval first. Prices exclude VAT.

Or a two-week hardening sweep

One C, C++ or Rust component that reads untrusted input, such as a parser, codec, runtime or VM. You get the bugs crafted input can trigger, each confirmed before it goes in the report.

  • Confirmed findings only
  • A reproducer for each
  • A fix for each

Two weeks. List price €6,000 / $7,000, introductory price €3,000 / $3,500 for the first few clients.

Working in your systems

  • I sign your NDA.
  • I work on a staging copy or with read-only access to production metrics.
  • Nothing touches production without your sign-off.
  • Changes come as normal pull requests through your CI.
  • What I build for you is yours once paid.

Recent open source work

I also harden code that handles untrusted input, with bounds checks in LLVM's C++ library, a fix for a hang in zstd on a crafted file, and a merged mruby fix for string lengths that wrapped at 2 GiB.

Pull requests to other projects (71)38 merged, 33 open, 21 projects

Also building

Ulanain development

Compiles WebAssembly to Luau. Ten real programs, including SQLite and QuickJS, match the wasmtime reference output.

Ganglionin development

A Rust and CUDA simulator for an entire fly brain, all 165,122 neurons, with hand-written and optimized CPU and GPU kernels. One simulated second runs in 0.37 s on a consumer graphics card (RTX 3070 Ti).

infdocin development

A command-line check for silent slowdowns in self-hosted LLM serving. Every rule comes from a measured case.

Who you would work with

Ilyas Mallah

Performance engineer for AI and backend systems

I'm a software engineer in the Netherlands, and I specialize in performance. Performance problems often fall between specialists. The symptom is a slow API or a costly AI model, and the cause sits in a query plan, a runtime or a GPU kernel. I work at all of those layers, so one person follows the problem from the symptom to the fix. I do that inside your codebase, with your tools. vLLM and llama.cpp were once codebases I had never seen before, and thousands of other specialists had already worked on optimizing them. I still found significant speedups in both.

So, something slower than it should be?

Email me the slow part, where it runs and the result you want, such as a latency or cost target. If you don't know the technical details, describe what's slow or what it costs, and I'll ask the rest.

I reply within hours, 9 am to 9 pm Amsterdam time.