Python & C/C++ Team Lead
Building high-performance OSS systems
Async • multiprocessing • shared memory • LLM infrastructure

• High-performance Python systems (beyond typical GIL-bound design)
• Inter-process communication (IPC) with minimal overhead
• Shared memory architectures
• Async runtimes and event loop engineering
• Systems-level optimization (C/C++ / Cython / low-level integrations)

Contributor to:

• Since Jan 2023: NiceGUI : I found a key issue in client-server event synchronization for interactive UI components (such as text editors). I identified the root cause, fixed it, and improved the overall mechanism of client-server event synchronization.
• Since Sep 2021: Kivy : Authored a fix for an important Windows issue in Kivy's core (included via an upstream PR).
• Since Jun 2024: Billion Row Challenge (Python) - Python section of The One Billion Row Challenge : I improved the performance of the pure Python implementations (for both CPython and PyPy) by an additional 10–20% (depending on the exact CPython and PyPy version).
• Since Jul 2026: awesome-mcp-servers : my Text File Read And Refactor MCP and CodebaseAgent-MCP have successfully passed automated analysis and manual review, qualifying them for inclusion in the list. I'm happy to be among the top developers of open-source MCP servers and MCP clients on GitHub.

High-performance IPC via shared memory.

• Zero/low serialization overhead approach
• Seamless sharing and mutation of Python objects across processes
• Supports:
  • NumPy arrays
  • Torch tensors
  • custom classes (including dataclasses)
  • objects with methods
  • asyncio integration

Core idea:
Move away from serialization-heavy IPC → toward shared-memory object models with controlled mutation.

Implementation stack:
Python + Cengal (Python, Cython, C)

Multi-domain high-performance Python toolkit.

Includes:

• Runtime bytecode manipulation
• True shared memory primitives
• Async integrations:
  • LMDB
  • Tkinter
  • wxPython
  • PySide / PyQt
• Custom async loop with near preemptive multitasking (single thread)
• Advanced introspection & text parsing tools

Implementation stack:
Python + Cython + C/C++ + Nim + Go

Unreal Engine 3 (UE3) compiler and decompiler for game modding.

Decompiles bytecode to, and compiles from, a simple to use Lisp-like custom language.

Used to implement the XCOM: EW mod: "Realistic Damage Model" at Nexus Mods; XCOM: EW mod: "Realistic Damage Model" at Github

Implementation stack:
Python + Cengal

A sub-harness (both an MCP server and an MCP client). Delegates documentation and source code analysis, as well as interactions with related context-providing MCP servers, to a local or inexpensive OpenAI-compatible LLM. Drastically reduces token usage and context size for coding agents on the top-tier LLM.

Core idea:
Let a cheap/local LLM explore docs/code. Let a top-tier LLM write code.

Implementation stack:
Python + Cengal + Text File Read And Refactor MCP

Token-efficient Python stdio MCP server exposing safe text-file search, reading, and refactoring tools. Tools automatically resolve the file BOM and codepage; edit tools save files with their original encoding and BOM.

Core idea:
Exports a simplified version of the cengal.text_processing.* modules from the Cengal library.

Implementation stack:
Python + Cengal

• Reducing Python overhead via architecture, not micro-optimizations
• Treating IPC as a first-class performance domain
• Bridging high-level ergonomics with low-level control
• Designing systems that scale beyond "standard async patterns"

Languages:
Python, C/C++, Nim

Domains:

• Async systems
• IPC / shared memory
• Systems programming
• Performance engineering

• Open for high-impact system-level work
• Focus: performance-critical backends, infra, unconventional architectures