Erik Kranjec

About Myself

A software engineer focused on understanding systems from the ground up. Always seeking to solve problems from first principles. I specialize in low-level systems and high-performance applications, with extensive C++ expertise gained across academic, personal and professional work. Equally skilled with higher-level languages with proven fluency in JavaScript/TypeScript for complex product delivery.

My core interests lie in complex domains like language design, real-time graphics (mostly experienced with SDL and OpenGL), and the challenges of building networked systems and multiplayer games (I implemented one from scratch). Beyond that, I actively enjoy recreational programming and participating in hackathons and CTF challenges. I use these side projects to expand my knowledge and explore new domains. This has provided me with direct experience with modern systems languages like Rust and Go, as well as functional paradigms like Haskell.

Projects

Rewind Engine (WIP)

Engine-agnostic, deterministic, rollback-capable multiplayer framework in C++23
  • Building a deterministic fixed-tick simulation core with fixed-point math and engine-generic snapshot save/restore over byte buffers.
  • Structured as reusable engine modules (sim, net, replay, common) with a headless authoritative server and a raylib + ImGui client running a minimal 2D arena demo.
  • Working toward rollback/resimulation, replay recording with checkpoints, and a custom UDP reliability protocol on top of Asio.

Voronoi Region Visualizer (Interactive)

Interactive voronoi diagram playground in C with raylib, compiled to WebAssembly
  • A voronoi diagram partitions the plane into regions, one per seed point, where each region covers everything closer to its seed than to any other.
  • Renders voronoi regions per pixel every frame: left-click adds or drags points, right-click removes them, and D cycles between euclidean, manhattan, and chessboard distance metrics.
  • Written in C with raylib and compiled to WebAssembly via emscripten and is playable on this page.

Duel Arena

Networked game with destructible terrain, built from scratch in C++
  • Designed and implemented a turn-based multiplayer architecture in C++, including client–server synchronization and custom message serialization.
  • Built a low-level rendering and UI stack with SDL2, OpenGL, and ImGui, maintaining explicit control over the game loop, frame timing, and input handling.
  • Owned the full system end-to-end: engine structure, networking, rendering, tooling, and debugging of latency and synchronization issues.

NP-Hard Problem Optimization

Heuristic based approaches to solving various NP-Hard problems, using Haskell and C++
  • Implemented a genetic algorithm + Solomon L2 heuristic solver in modern C++ for the Capacitated Vehicle Routing Problem with Time Windows (CVRPTW).
  • Implemented GRASP and Tabu Search for Fantasy Football and Quadratic Assignment problems.
  • Designed custom data structures, fitness evaluation, crossover, and mutation strategies with a focus on performance and scalability.
  • Part of a Heuristic Optimization Methods class I achieved the highest grade at. My CVRPTW solver ranked 2nd best in low-time (10s) performance, generating high-quality routes extremely quickly.

Open Source & Smaller Tools

Automation, developer utilities, and various technical experiments
  • mermaid-erd-to-sql – Added a standalone command-line interface to an existing VS Code extension, enabling headless usage and scripting.
  • ToDoBot – Automation bot project for Discord, focused on Discord API integration and maintainability.

Experience

Once Sport — Software Engineer (Current)

Multi-camera stitching and camera tracking for Once Sport Autocam (C, C#)
  • Filled uncovered regions of wide-angle stitched frames with blurred content in a core C multi-camera stitching library.
  • Implemented push-pull inpainting with temporal smoothing in C, staying below a 40% per-frame overhead budget.
  • Developed a camera tracking stage for handball and basketball, following play with court-third framing and lookahead smoothing.
  • Developed the drawing timeline for the Once Sport Video Analyser in C#.

Reactor Studio — Software Engineer

Geospatial and weather data platform (TypeScript, Node.js, PostgreSQL, React)
  • Built a map-based platform in React and Leaflet for creating and configuring geo-located entities.
  • Developed a weather prediction API in Node.js/TypeScript with spatial PostgreSQL queries via Prisma.
  • Prototyped backend services for processing large-scale geospatial and meteorological datasets.

Google — Software Engineering Intern

Native Linux GUI for real-time MediaPipe effects (C++, ImGui, SDL2)
  • Built a native Linux GUI in C++ (ImGui, SDL2) to configure and preview real-time MediaPipe ML effects.
  • Owned the windowing, rendering loop and input handling; debugged frame timing and event-loop issues.
  • Added real-time controls and gesture simulation for faster interactive testing; wrote the C++ test suite.
  • Cut iteration time on effect creation/testing by 10× (~120s to ~12s).

KRTECH — Software Engineering Intern

Backend, database and cloud infrastructure for IoT devices (Node.js, PostgreSQL, AWS)
  • Designed the system-wide PostgreSQL database architecture, schema design and optimization.
  • Built Node.js/TypeScript REST API backends with near real-time communication to ESP32 devices over MQTT.
  • Deployed the MQTT broker and database on AWS (EC2, RDS); set up CI/CD with Bitbucket Pipelines.
  • Built React, Next.js and TypeScript web applications with IoT device integration, now in production.

Academic & Independent Systems Work

Low-level programming, algorithms, and performance-oriented projects
  • Extensive C++ experience across academic, personal, and professional contexts, with a focus on correctness and explicit control over resources.
  • Regularly explore systems languages like Rust and Go, and functional paradigms like Haskell through side projects, hackathons, and CTF challenges.
  • Strong interest in language design, real-time graphics, networking, and building performance-sensitive systems from first principles.

Yep. That's all (for now :D).