🎓 Computer Engineering student at Istanbul University · from Türkiye 🇹🇷

⚙️ → I build native, performance-oriented systems.
🧠 → My work lives at the intersection of machine learning, compilers and heterogeneous hardware.
🧩 → I develop feature-discovery runtimes, compiler frontends and accelerator backends.
🤖 → Many of my projects are designed with AI agents as first-class consumers.
📊 → I care about measurable performance, explicit evidence and reproducible engineering.
🚀 → I enjoy moving abstractions closer to the hardware without hiding their real trade-offs.

I am interested in the layers where machine-learning ideas stop being notebooks and become real systems:

• ⚙️ Native execution engines
• 🧠 Machine-learning systems and feature discovery
• 🧩 Compilers, DSLs and intermediate representations
• 🚀 CPU, GPU, NPU and heterogeneous computing
• 🤖 AI coding-agent infrastructure
• 📊 Deterministic benchmarking and performance analysis
• 🔬 Research-driven open-source engineering

My work usually starts with a question like:

Can this abstraction be made faster, more deterministic, more inspectable, or closer to the hardware?

And then it somehow turns into a Rust, C++, CUDA, HIP, MLIR or compiler project. 😅

I care about systems whose claims can be supported by reproducible experiments, benchmarks, profiler reports, regression tests, explicit acceptance criteria and inspectable artifacts.

A confident answer is useful.
A verified answer is better.

GAFIME is a native feature-interaction mining engine for tabular, structured and time-series machine-learning workflows.

It is designed for workloads where interaction candidates, threshold regions and temporal transformations become too expensive to explore through ordinary Python loops or repeated model training.

Python API
    │
    ▼
Rust validation · planning · orchestration · CPU SIMD
    │
    ├── CUDA payload
    ├── ROCm / HIP payload
    └── Apple Metal payload

• continuous feature interactions,
• soft discrete thresholds and intervals,
• rectangular decision regions,
• causal time-series transformations,
• native CPU SIMD execution,
• GPU-accelerated candidate evaluation,
• scikit-learn integration,
• large-file streaming workflows,
• and future compiler-driven execution.

The larger goal is not merely to generate more features.

It is to build an engine capable of discovering, evaluating and executing useful feature structures efficiently across different hardware backends.

MatcoreDSL explores compiler-oriented execution for matrix-centric systems work. It preserves ordinary C++ while capturing explicitly marked matrix operations through a native frontend, typed IR and deterministic runtime planning.

Valid C++ / .mdsl
        │
        ▼
Clang LibTooling frontend
        │
        ▼
Typed Matcore IR
        │
        ▼
Legality · Capability · Planning
        │
        ▼
Native CPU execution and packaged consumers

Current validated work includes:

• an in-process Clang frontend,
• typed operation and memory contracts,
• deterministic CPU GEMM planning,
• scalar, tiled, compiler-vectorized and native packed paths,
• AVX2 / AVX-512 capability-aware execution,
• persistent parallel CPU workers,
• Linux and Windows x64 compiler/runtime validation,
• installed-package and external-consumer acceptance,
• and milestone-driven adversarial review.

MatcoreDSL is developed through bounded engineering milestones: every new operation, backend or optimization must prove legality, correctness, packaging and its declared performance scope before becoming part of the supported surface.

PerfDigest is a local MCP server that sits between development-loop artifacts and AI coding agents.

Profiler reports, compiler traces, benchmark results and CI logs are often vendor-specific, verbose and expensive to place directly inside an LLM context window. PerfDigest turns them into compact, deterministic and numeric digests while preserving references to the original evidence.

Profiler · Build · CI · Repository Artifacts
                     │
                     ▼
             ┌─────────────────┐
             │   PerfDigest    │
             │ Parse · Normalize│
             │ Route · Compress │
             └─────────────────┘
                     │
                     ▼
        Compact evidence for coding agents

One of the project's most important rules is:

A missing metric must never silently become a zero. Feeding fabricated performance information to an AI agent is worse than returning no information at all.

PerfDigest is intentionally a translator and router, not an oracle. It exposes evidence efficiently; the model still has to reason about it.

Real-tool workloads, release behavior and measured claims are exercised in the public PerfDigest-MCP-Bench repository. The benchmark suite is expanded and rerun as new PerfDigest releases add backends, contracts and performance-analysis workflows.

Experimental downstream PyTorch backend research for AMD XDNA NPUs.

• real XRT-backed tensor storage and execution,
• eager and out-of-tree Inductor integration experiments,
• fail-closed unsupported-operation boundaries,
• artifact, cache and acceptance-evidence discipline,
• and physical XDNA validation across a deliberately narrow surface.

This remains a private developer preview while release, artifact and support boundaries are being finalized.

Experimental local-first runtime for coordinating independent AI coding agents.

• typed event protocols,
• isolated Git worktrees,
• durable state and crash recovery,
• artifact and benchmark exchange,
• policy and approval boundaries,
• and adversarial multi-agent review.

The project remains private while its core parallel-coordination hypothesis is still being evaluated. A working runtime is not enough; the collaboration model must also prove that agents can make progress without corrupting each other's work.

• GAFIME v1.x — release hardening, trustworthy feature discovery and future data-science field expansion
• MatcoreDSL — compiler frontend, typed IR and native CPU performance milestones
• torch-xdna — private AMD XDNA developer preview and PyTorch backend research
• PyTorch contribution work — learning upstream ownership, review and contribution workflows

• compiler internals and native frontend architecture,
• MLIR / LLVM lowering and optimization infrastructure,
• heterogeneous runtime and accelerator backend design,
• GPU kernel optimization and performance diagnosis,
• evidence-driven AI-agent workflows,
• and sustainable open-source maintenance.

• expand GAFIME v1.x into additional data-science fields such as computer vision and natural-language processing,
• become a trusted contributor in the PyTorch and Torch Foundation ecosystem,
• and contribute meaningfully to major open-source infrastructure projects such as PyTorch, Triton, LLVM and the Linux kernel.

One performance problem, followed all the way down the stack.

Honestly, I did not begin with a perfectly designed systems roadmap. 😅
I kept following every uncomfortable question that GAFIME exposed, and each answer pulled me one layer deeper into systems engineering.

My current engineering path begins with GAFIME.

GAFIME feature discovery
          │
          ▼
Native CPU · CUDA · ROCm · Metal execution
          │
          ▼
Compiler and runtime boundaries
          │
          ├── MatcoreDSL
          │     Clang frontend · Typed IR · Native planning
          │
          ├── PerfDigest-MCP
          │     Evidence-efficient performance intelligence for agents
          │
          └── torch-xdna / Synclave
                Accelerator backends · Agent execution infrastructure

GAFIME taught me that a machine-learning idea becomes much more interesting when it has to survive real hardware, real packaging, real performance limits and real evidence requirements.

That experience shaped the rest of my work:

• MatcoreDSL explores how compiler structure and typed execution contracts can turn intent into validated native programs.
• PerfDigest-MCP explores how coding agents can consume performance evidence without drowning in raw profiler output.
• torch-xdna explores narrow but physically validated PyTorch execution on AMD XDNA hardware.
• Synclave explores whether independent agents can coordinate through durable state, isolated workspaces and explicit acceptance criteria.

I enjoy building systems where ideas are not only interesting on paper, but also implemented, measured, challenged and stress-tested honestly. 🧪

I am interested in execution systems where models, transformations and hardware kernels are optimized as a unified program.

Potential directions include operation fusion, model-specific code generation, execution-graph specialization, static interaction planning, runtime backend selection, kernel caching and hardware-specific compilation.

Coding agents are becoming capable enough that their biggest limitations are increasingly infrastructural:

• context loss,
• weak state management,
• unverifiable claims,
• shared-workspace conflicts,
• missing provenance,
• and ambiguous completion conditions.

Many of my projects are designed with agents as first-class consumers. GAFIME's structured native reports, PerfDigest's compact evidence contracts and Synclave's durable coordination model all reflect that direction.

I am interested in systems where agents operate through durable state, typed protocols, isolated workspaces and measurable acceptance contracts.

I am especially interested in collaborating on projects involving native machine-learning infrastructure, compiler and runtime engineering, GPU/NPU/heterogeneous computing, tabular deep learning, performance-analysis tooling, AI coding agents, MCP infrastructure and research-oriented open-source systems.

Build deeply. Measure honestly. Ship reproducibly.

Thanks for visiting 👋