Hi! I'm Akram, and I specialize in the development of bare-metal software where every cycle and byte is manually managed. My work centers on ruling out abstraction by implementing fundamental subsystems, from memory management to network protocols, directly against the hardware. I maintain control over execution determinism and system performance by building monolithic kernels and 3D engines from scratch.
- Systems Programming
- Implementation of a 64-bit graphical operating system and drivers for NVMe + Intel HDA hardware via MMIO and DMA
- Development of Slab and Arena allocators for O(1) memory access and minimal heap fragmentation
- Performance Optimization
- Low-level optimization for x86-64 using SIMD (AVX/SSE) and bitwise operations
- Application of lock-free atomics and cache-line alignment to maximize throughput in concurrent environments
- Networking & Protocols
- Engineering custom UDP libraries and stacks with zero-copy I/O and polled drivers
- Bypassing kernel overhead for high-frequency packet processing and packet analysis
- Applied Mathematics
- Implementation of linear algebra and computational geometry within rendering pipelines and spatial partitioning systems
- Application of discrete mathematics and reinforcement learning (Q-Learning) for simulation and fault-burst mitigation
Mira (Custom x86-64 Monolithic OS)
A 64-bit monolithic kernel written from scratch to handle high-frequency fault bursts. The architecture relies on a custom O(1) Slab Allocator to ensure deterministic memory access patterns, alongside asynchronous NVMe drivers and a polled UDP stack for zero-copy packet processing.
Tori (Custom 3D Rendering Engine)
A high-performance rendering engine with 16-byte aligned SIMD mathematics and hardware cache-line locality. It features a custom Linear Algebra library, Octree spatial partitioning for O(log N) search complexity, and a skeletal animation system with matrix hierarchies.
Geo (Low-Latency Multiplayer 2D Engine)
A multiplayer engine optimized for unstable networking environments using a custom server-authoritative UDP protocol. The core loop uses C++20 multithreading to decouple network processing from logic, which minimizes frame-time spikes, while entity and scripting logic are handled via Lua coroutines for non-blocking execution.