Hello world
Or: how a programmer says hi.
Debug.Log("hello world");It's where pretty much every programmer starts – the first line that prints hello world to the screen. Hello world. And that's exactly how I want to say hi to everyone who ends up here – as simply as that.
What a screenshot doesn't show
A portfolio, by definition, shows what can be shown – projects, screenshots, sometimes a trailer, a short description, my role. That makes sense. But it's only one part of the work, the more visible one. Everything else usually stays off to the side.
A screenshot doesn't show that a system works almost well – and that "almost" is often the real problem. It doesn't show the debug views, the little tools I built for myself, or the workflow tweaks that look like nothing but genuinely save time.
And honestly, those are the things that stick with me the most. Not a particular frame from the game, but a bug that wouldn't let go. A system that looked simple and then split into several cases. Or a small tool built just to check something faster – that then quietly stays in use for a long time.
Not everything that matters looks good in a screenshot.
A few words about me
There had been a computer at home for as long as I can remember, and it always fascinated me – I still recall the DOS days, though I was far too young to program then, and playing games wasn't really an option either. So it's no surprise my story went this way.
For a long time it mostly revolved around gaming, until at some point I wanted to do something more, to be a bit more ambitious. That's how I started exploring things around programming. The first thing I ran into was HTML and CSS – not really programming, but I could make something that showed up on screen, and I immediately liked that. And since I loved games, the direction picked itself: those were what I wanted to make.
At first I was a bit lost – I didn't really know where to begin. The turning point was stumbling onto the first genuinely good video course on C++, explained in a way that finally clicked. It completely absorbed me, and after finishing something like that, all I wanted was to go further and further. What I worked through back then was mostly console applications – I understood how code worked, but I was still stuck in a black console, and I wanted to see something on screen.
Later came graphics libraries and low-level OpenGL. Except the jump from the console and the basics straight to something that big was simply too much – far more than you need just to make a simple little game. A big part of the time back then went into the sheer fight to get anything on screen at all – vertices, triangles, shaders, all that plumbing. It was interesting, but it could eat dozens of hours with still no game to show for it. And I just wanted to make games.
The next step was Unity. A ready-made engine where everything that used to cost me so much time and nerves was simply there, ready to use – and in a way that was finally accessible to me, because it had an interface. A real editor, an actual tool where you see the result right away. I thought: this is it. And the interesting part is that none of that earlier struggle went to waste – over time, once I'd been working in Unity for a while, all those scattered pieces of knowledge, even the OpenGL that had felt like too much back then, fell into place. I could finally just make games, and along the way I actually started to understand how it all works underneath.
To this day, what I like most is the moment something finally works – and the whole road that leads there. Working a system out, fighting a bug that won't give up, and that instant when an algorithm clicks into exactly the right place.
And even though back then all I wanted was to see something on screen, something moving, what I'm most grateful for today is the technical grounding I built along the way. It's what now lets me work with the things you don't see on screen – the algorithms and logic that, somewhere underneath, make the whole thing work at all. And honestly, that hidden part is the one I find most interesting to write about.
What this is, and what it isn't
This is not a daily blog. There's no schedule, I'm not writing for the algorithm, and there won't be any SEO keyword series. I'd rather post rarely and mean it than fill the space just to keep it busy.
It's the looser part of the site – observations from work, the more interesting problems, tools made along the way, and things you won't find on a project page but that still feel worth mentioning. Written plainly, without dressing them up.
Because, honestly, for me this isn't only a portfolio. It's been almost twenty years since I first got pulled into all this, and in a way this blog is also a quiet record of that road – a place I'll be able to come back to myself one day. But the history is only one side of it – I hope that, all these years in, I stay just as curious and keep growing.
If you've made it this far – hi. I hope you find something here for yourself. If you ever want to talk about anything I write, the contact links are on the main page.