Luka Pajkanovic
Systems & Web Developer
I build high-performance software, systems-level logic, scalable web architectures, and interactive game mechanics from scratch. Focused on deterministic engineering, clean memory models, zero-overhead abstractions, and tactile digital interfaces.
Technologies & Architecture
A disciplined set of systems-level languages, asynchronous pipelines, and modern web frameworks used to engineer resilient digital systems.
Low-level memory management, linear arena allocators, deterministic game loops & cache-friendly SIMD layouts.
LinearArena::alloc<Packet>(sizeof(T));[01]WEB & RUNTIMES
Modern frameworks, server runtime environments, and styling libraries for fast, responsive web systems.
- React 19Component Architecture
- Next.js 15App Router & SSR
- Node.jsAsync Runtimes & APIs
- Tailwind CSSDesign Tokens & Styling
- Framer MotionSpring Physics & Motion
- AstroContent-Driven Framework
- REST APIsDistributed Service Contracts
[02]DEVOPS & INFRASTRUCTURE
Containerization, continuous integration, version control, and Linux systems administration.
- GitLab CI/CDAutomated Multi-Stage Pipelines
- GitHub ActionsAutomated Multi-Stage CI/CD
- DockerMulti-Stage Containers & Isolation
- Linux / POSIXShell Scripting & Server Admin
- GitBranching Strategies & Commits
- GitHubVersion Control & Repositories
- CloudflareEdge Routing, DNS & Security
- CMakeC++ Build Systems & Toolchains
[03]GAME & SYSTEMS SPECIALIZATIONS
Engine mechanics, client/server replication, game architecture, and workflow automation.
- Roblox ArchitectureState Replication & Netcode
- Game Loops & PhysicsFixed-Step Simulation
- Data-Oriented DesignCache Optimization & Memory
- Automation & ScrapingTask Queues & ETL Workflows
Building software with intention, deterministic logic, and precision.
As a systems and web developer, I favor clean memory models, compile-time type safety, and architectures that feel instant and unyielding under heavy load. From native engines to async web pipelines, the discipline stays the same: measure first, abstract only what earns its cost.
Systems & Memory Models
Data-oriented architectures designed around CPU cache lines, deterministic fixed-timestep simulation loops, and custom contiguous memory arenas preventing heap churn.
Web Architecture
Strict type contracts, Next.js standalone container runtimes, and sub-100ms response cycles.
Game Netcode & Replication
Delta compression packets, client-side extrapolation, and authoritative state loops.
Automated Verification & CI/CD
Multi-stage Docker containers, cached build runners, and automated GitHub Actions pipelines.
Active Engineering Radar
Focused exploration tracks pushing deeper into low-latency concurrency, graphics shaders, and distributed consensus models.
Low-Latency Concurrency & Lock-Free Structures
Exploring lock-free queues, atomic operations, cache-line bouncing prevention, and memory order semantics.
Graphics Pipelines, Shaders & Render Math
Investigating modern compute shaders, vertex/fragment buffers, and spatial acceleration trees (BVH).
Distributed Consensus & Edge State Machines
Researching raft consensus, deterministic state replication across unreliable networks, and edge caching.
LET'S ENGINEER
SOMETHING RESILIENT.
Have a low-latency systems challenge, a web architecture to discuss, or looking to collaborate? Reach out directly.