Zishaan Ahmed — software & systems engineer

01

Helmsman

v1.0.0

GitOps deployment with an AI risk gate and self-healing rollback. Push code, and Helmsman containerizes it, renders the manifests, reviews the risk and commits the change for ArgoCD or Flux to roll out.

• Seven small Go CLIs that run in CI and as a cluster CronJob. Nothing calls the Kubernetes API to make a change: every deploy is an auditable, revertible Git commit.
• AI is used in exactly two places, risk review on top of static policy checks and plain-English root-cause analysis. Both fall back to deterministic output when the model is unreachable.
• Rollback is a git revert triggered by health rules, never a model decision.

• 85.7% test coverage
• 0 dependencies
• 7 CLIs, one image

• Go
• Kubernetes
• ArgoCD
• Flux
• Docker
• Gemini
• GitHub Actions

sourcewebsiterelease

git push
   │
   ▼
detect ─▶ containerize ─▶ render manifests
                                 │
                                 ▼
                          AI risk review
                          policy + Gemini
                                 │
                                 ▼
ArgoCD / Flux ◀──── commit to GitOps repo
   │
   ▼
health-watcher ── healthy ──▶ done
   │ unhealthy
   ▼
git revert + AI root-cause issue

02

Vector

C++20

A real-time simulator for autonomous interception: physics, noisy sensing, Bayesian state estimation, guidance and control composed into one closed loop.

• A constant-velocity Kalman filter tracks the target through Gaussian noise and dropped detections, and its covariance is drawn as a true uncertainty ellipse.
• True proportional navigation and pure pursuit behind one interface, with an iterative intercept-point predictor and a jerk-limited actuator model.
• Headless Monte Carlo runner: up to 50,000 deterministically seeded trials per batch, scoring success rate, miss distance and robustness to sensor noise.

• 74.3% intercept rate vs evasive targets
• 50,000-trial batches
• 120 Hz RK4 physics

• C++20
• Eigen
• OpenGL 3.3
• Dear ImGui
• ImPlot
• doctest
• CMake

source

┌─▶ RK4 physics ─▶ noisy sensor
│   120 Hz step     noise + dropout
│                        │
│                        ▼
│                  Kalman filter
│                  6-state CV
│                        │
│                        ▼
│                  guidance law
│                  a = N·Vc·(ω × r̂)
│                        │
└── controller ◀─────────┘
    lag + jerk limit

03

GASX

MUBA ’26 finalist

An Ethereum gas futures exchange on Sui. It turns blockspace congestion into a tradeable index, and lets anyone who pays gas hedge it.

• Led the build of EGSI, a 0–1000 index of Ethereum blockspace stress computed from live chain data, with an AI forecast on top.
• One-hour EGSI futures settle in USDC through Move contracts on Sui, deliberately not the chain whose congestion is being traded. The house book is hedged with ETH options on Thetanuts (Base).
• Every AI action passes a policy layer first: position caps, 1% max slippage, 70% minimum confidence and an isolated wallet.

• Finalist MUBA Hackathon 2026
• Honourable mention from Sui

• Move
• Sui
• TypeScript
• Python
• C++
• React
• MySQL
• Docker

source

ETH base fee · mempool
        │
        ▼
EGSI engine   Python + C++
index 0–1000 + AI forecast
        │
        ▼
API gateway ─▶ trading terminal
        │      + Kora copilot
        ▼
Sui / Move ◀──▶ Thetanuts
EGSI-1H futures  ETH options hedge

04

Kerrscope

v1.1.0

A real-time Kerr black hole ray tracer. Gravitational lensing isn’t a screen-space effect here: every pixel’s photon path is integrated through curved spacetime on the GPU.

• Integrates Hamilton’s equations for null geodesics in the Kerr metric with RK4, using analytic derivatives of the inverse metric, inside an OpenGL 3.3 fragment shader.
• Accretion disk with redshift, Doppler shift and beaming, orbiting bodies lensed into thin arcs, and black-hole spin adjustable live.
• Runs on GPUs as old as Intel HD 4000. Static release binaries for Linux and Windows, with published SHA-256 checksums.

• 1 geodesic per pixel
• OpenGL 3.3 no compute shaders

• C++17
• OpenGL 3.3
• GLSL
• GLFW
• GLM
• CMake

sourcewebsiterelease

                    .-=+**+=-.
                 -#%*=:....:=*%#-
               =%*:    -++-    :*%=
             .*%-   ##      ##   -%*.
             +%:  .@          @.  :%+
            .#*.  @            @  .*#.
 -===+++***###%%%@@@          *@+++*#====----::::
                =.@            @.=
                 =.@          @.=
                  --##      ##--
                     -==++==-

05

SmolGPT

51.1M params

A GPT-style language model written and trained from scratch, which now runs entirely in your browser.

• Decoder-only transformer in PyTorch: 8 layers, 8 heads, 512-dim embeddings and tied input/output weights, trained on TinyStories.
• Fixed free-tier Colab out-of-memory crashes by streaming tokens into a memory-mapped file. Checkpointing and auto-resume survive disconnects on a single T4.
• bf16 mixed precision, cosine learning-rate schedule with warmup, gradient accumulation and clipping.

• 1.2 validation loss by epoch 5
• 1× T4 GPU

• Python
• PyTorch
• CUDA
• Hugging Face

try it in your browsersourcehugging face

TinyStories ─▶ tokenizer
                  │ streamed
                  ▼
            memmap .bin
                  │
                  ▼
      token embedding · 512
                  │
       ┌──────────▼──────────┐
       │ causal self-attn    │
       │         ▼           │ × 8
       │        MLP          │
       └──────────┬──────────┘
                  ▼
        LM head (tied weights)

06

OpenRover

in progress

A simulation-first autonomous rover platform. The autonomy stack sits behind one hardware abstraction layer, so the same code runs in Gazebo now and on a physical rover later.

• Differential-drive kinematics and rover state management in C++20, covered by GoogleTest and built with CMake.
• Architecture for simulator-independent algorithms, reproducible experiments, fault injection and telemetry.
• Planned path from sensor simulation through localization, SLAM, planning and obstacle avoidance to autonomous missions, behind an ASP.NET Core API and a web dashboard.

• C++20
• CMake
• GoogleTest
• ASP.NET Core
• PostgreSQL
• Docker
• Python

source

web dashboard ◀──▶ ASP.NET Core API
                          │
┌──── OpenRover core · C++20 ────┐
│ sensors ─▶ localization        │
│    ─▶ mapping ─▶ planning      │
│    ─▶ control ─▶ missions      │
└─── hardware abstraction layer ─┘
      │                    │
   Gazebo              physical
   (now)            rover (later)

R1

How Long is the Graph of xⁿ?

Logarithmic corner defects in arc length · Z. Ahmed · preprint, Zenodo, 2026

As n → ∞ the graph of y = xⁿ on [0, 1] turns into a corner, so its length tends to 2. The paper works out exactly how fast.

L(n) = ∫₀¹ √(1 + n²x²ⁿ⁻²) dx  ⟶  2

2 − L(n) = (ln n + 1 − ln 2)/(n − 1) + O(ln²n / n²)

• An exact, rapidly convergent Gamma-function formula for L(n), derived from a single Beta integral.
• Corners of any turning angle θ: the coefficient of (ln n)/n is 2 sin²(θ/2).
• By contrast the squircle |x|ᵖ + |y|ᵖ = 1 has no logarithmic term. Every numerical claim is recomputed by a script.

• asymptotic expansion
• Beta & Gamma functions
• Mellin transform
• mpmath

doi:10.5281/zenodo.22970394LaTeX + verification

y
1 ┤                                      .#
  │                                   ...:#
  │                                ...:::+#
  │                             ... ::: ++#
  │                          ...   ::  ++ #
  │                       ...    :::   + ##
  │                    ...     :::    ++ #
  │                 ...     ::::     ++  #
  │              ...      :::       ++   #
  │           ...      ::::       +++    #
  │        ...      ::::         ++     ##
  │     ...     :::::         ++++      #
  │  ...   ::::::         +++++        ##
0 ┼#####################################
  0                                      1 x

  . n=1   : n=2   + n=6   # n=40

R2

A Hybrid Learning Framework for Automated SAT Solver Selection

Z. Ahmed and T. Kwan Lee · research proposal, Zenodo, 2026 · Final Year Project, UTAR

Per-instance SAT solver selection that fuses handcrafted SATzilla-style features with graph-neural-network embeddings of the literal–clause graph, and measures what each representation actually contributes.

• The feature-only selector closes 73% of the gap between the single best solver and the virtual best on SAT18-EXP.
• The graph branch is 28× cheaper to compute than SATzilla’s probing features.
• Pre-registered paired significance tests, family-held-out folds and nested-CV tuning, with negative results reported as plainly as positive ones.

• PyTorch
• graph neural networks
• ASlib
• CDCL solvers

doi:10.5281/zenodo.22763759source

        ┌─▶ SATzilla features ──┐
        │                       │
CNF ────┤                       ├─▶ selector
        │                       │      │
        └─▶ literal–clause ─────┘      ▼
            graph ─▶ GNN          best solver
                                  for this
                                  instance