I use GitHub as a place to build, experiment, learn, and document what I create.
My repositories range from applications and developer tools to system-level experiments, web projects, hardware integrations, simulations, and AI-related work.
I don't like being limited to one technology or one type of project.
I'm a developer with a strong interest in building real software and understanding how things work under the hood.
A lot of my work is driven by curiosity:
- building something from scratch
- learning a new technology by actually using it
- turning an idea into a usable tool
- experimenting with different architectures
- connecting software with hardware
- solving problems through code
- improving projects as I learn
My GitHub is probably a better representation of my interests and technical growth than a list of titles ever could be.
You can see that progression across my repositories — from early web and backend projects to desktop applications, automation tools, embedded systems, simulations, AI experiments, and more recent production-oriented work.
I enjoy building complete applications rather than isolated code examples.
Some of my repositories include desktop applications, web applications, developer utilities, management systems, and tools designed around real use cases.
I like working close to the system when a project requires it.
That includes things such as:
- device communication
- command-line tooling
- controller input handling
- Android ADB / Fastboot workflows
- hardware communication
- automation
- low-level experimentation
My repositories include both frontend and backend work, including:
- REST APIs
- authentication
- CRUD systems
- database-backed applications
- real-time communication
- React applications
- Django projects
- modern full-stack architectures
I'm interested in using AI where it can solve an actual engineering problem.
My projects include experimentation with:
- computer vision
- object detection
- edge inference
- local LLM tooling
- autonomous driving simulation
- AI-assisted developer workflows
I also enjoy projects where software interacts directly with physical systems.
That includes Arduino, ESP32, sensors, displays, GSM modules, EEPROM storage, Raspberry Pi and other hardware-oriented experiments.
These are some of the projects that represent different parts of my development journey.
A Python-based tool that maps game controllers to a virtual Xbox/XInput device using ViGEm and HID input.
A good example of the kind of problems I enjoy: taking low-level input and turning it into a practical developer/user-facing tool.
An experimental project around CARLA and autonomous-driving simulation.
This represents another part of my interest: experimenting with simulations and systems where software interacts with a virtual environment.
An edge computer-vision pipeline built around YOLOv8n, ONNX Runtime and Raspberry Pi 4, with an emphasis on lightweight CPU inference and practical deployment.
The repository is structured around reusable source code, configuration, data, models, notebooks, examples and tooling rather than being just a single inference script.
A hardware/software system for monitoring water usage using flow sensing, persistent EEPROM storage and GSM-based remote interaction.
The project includes an Arduino side as well as a Django backend and focuses on practical concerns such as interrupt-driven counting, persistent data, SMS parsing and non-blocking communication.
A desktop browser project built with Python and PyQt.
Another example of experimenting with application architecture, desktop interfaces and practical software tooling.
A Python desktop utility for working with Android devices through ADB and Fastboot.
It provides both GUI and CLI interfaces and includes device management, application management, screenshots, screen recording and reboot functionality.
My repositories also include work around:
Django · Django REST Framework · React · Vite · PyQt · C++ · C# · Rust · PostgreSQL · OpenCV · NumPy · Arduino · ESP32 · Raspberry Pi · WebSockets · ADB · Fastboot · Pygame · CARLA · ONNX Runtime
The interesting part is not the list itself.
The interesting part is the range of problems those technologies have allowed me to work on.
Idea
↓
Experiment
↓
Build
↓
Understand
↓
Refactor
↓
Improve
I prefer learning by building.
Instead of only reading about a technology, I usually try to use it in a real project, understand where it works, understand where it breaks, and then improve the implementation.
That approach is reflected in my repositories.
Clean code
Good architecture
Useful software
Performance
Learning by building
Understanding systems
Continuous improvement
I don't consider a project finished just because it runs.
There is always something that can be understood better, simplified, optimized, or rebuilt properly.
I'm continuing to expand the range of systems I can build, while going deeper into software engineering, architecture, performance, AI, systems programming, and modern development workflows.
The best way to understand what I know is to look at the code.
