Software engineer · Kyiv, Ukraine
I build software across product, infrastructure, protocols, automation, and AI — mostly with Swift, Rust, Ruby, TypeScript, and Python.
I started on the client side and still care about interfaces, but most of my recent work lives deeper in the stack: deterministic cores, explicit authority boundaries, provider-independent systems, deployment, observability, and small tools that remove repeated work.
I also write poetry. That probably explains why I care more than is strictly necessary about naming, rhythm, and removing words or abstractions that do not earn their place.
0xda-sha— deterministic visual fingerprints for Git commit digests. A small Rust library-first system where the fingerprint semantics live in a deterministic core and SVG / CLI / Git integration stay outside it.0x1— an experimental peer-to-peer social protocol built around bilateral interactions, portable identity, human and artificial participants, and the idea that an operator should not own the social graph.Prism— a provider-agnostic publishing engine: one intent can become explicit variants and deterministic delivery across providers without pushing provider semantics into the core.4x-errors— a shared error-reporting protocol, SDK boundary, and collector designed so the reporting system can fail without becoming the application's failure.0xda-market— an experimental commerce system with auction mechanics and deliberately separated domain, provider, bot, and client boundaries.mind— a versioned public context graph for my identity, projects, engineering decisions, organisations, and writing.ping-pong-MACHINE— a very small new experiment around distributed synthetic traffic, availability, and edge observation.
Some of these are products, some are research, and some are infrastructure I needed badly enough to stop solving the same problem twice. I do not pretend they are all at the same maturity level.
infraCLI · infraBot · mcp-control · ReX · swiftui-dsl · Serverable · SwiftStomp
They range from infrastructure control and MCP tooling to UI experiments and older Swift work. I keep them public when the code or the idea is still useful, not to make the repository count look larger.
I prefer contracts over assumptions, explicit boundaries over hidden coupling, and predictable code over clever code.
Swift is the language in which I have the longest production history. Rust is where I increasingly put deterministic shared cores and portable logic. Ruby is useful when product speed and expressive server-side code matter. TypeScript is the practical language around web surfaces and integrations. Python is useful for automation, data work, experiments, and AI-facing tooling.
AI is part of the toolchain and, in some projects, part of the product. I am much more interested in permissions, authority, local execution, observable actions, and failure semantics than in putting an AI label on ordinary software.
The recurring pattern in my work is simple: make the important state explicit, keep ownership clear, and make failure visible before it becomes mysterious.
- GitHub:
0x0sky - public context:
mind - 0x1:
nilx-one - shared engineering projects:
aiaiaiai-org - commerce experiments:
0xda-market
Code is a decision made executable.
Poetry is what remains when execution is not enough.