Architecture & Technologies

When I need absolute control over CPU cycles and memory management, I drop down to the system level. In performance-critical workloads, I prefer talking directly to the hardware over relying on bloated abstractions.

• C
• C++
• Rust

In bare-metal environments with strict hardware constraints, I write pure C, C++, and Rust. I only transition to C# if the project demands high-level IoT interfaces.

• C
• C++
• Rust
• Bare-Metal

For raw image processing and rendering pipelines, I skip high-level engines. To squeeze every drop of performance from the GPU, I write C++ talking directly to OpenGL, DirectX, and OpenCV.

• C++
• OpenCV
• DirectX
• OpenGL

My preferred web architecture: pairing fluid, type-safe React/Vue interfaces with the brute speed of Rust backends. I usually let Nginx orchestrate the traffic.

• Next.js
• Nuxt.js
• Rust (Actix)
• Nginx

I treat the frontend strictly as an interactive consumption layer. While I use giants like React/Vue, my absolute favorite is Svelte to escape Virtual DOM overhead and achieve ultra-light builds.

• React
• Vue
• Svelte
• TypeScript

The workload dictates the tool: C++ or Rust for unforgiving performance, Go for highly concurrent microservices, and C# when I need to ship robust features fast.

• C++ (Boost)
• Rust (Actix)
• Go (Fiber)
• C# (ASP.NET)

The workload dictates the database, not trends. I use PostgreSQL for relational integrity, MongoDB for flexible docs, and SQLite or RocksDB for microsecond-latency caching.

• PostgreSQL
• MongoDB
• SQLite
• RocksDB

Moving beyond standard protocols, I design privacy-centric architectures operating over Tor and Lokinet. To leave zero footprint, I serve dynamic HTML directly from RAM using C++ and Rust.

• Tor Onion
• Lokinet
• C++
• Rust
• RAM-Only

Tauri is great for web-based desktop UIs. But if the OS requires deep integration or a purely native Windows feel, I pivot straight to C# (WPF) and C++.

• Tauri
• C# (WPF)
• C++
• Native Desktop

Flutter is my default for mobile. Dart's C++-like syntax and AOT compilation let me build cross-platform projects rapidly without sacrificing that native performance feel.

• Flutter
• Dart
• AOT Compilation

I use Rust (Bevy) for data-oriented simulations, and C++ (Raylib) for zero-cost rendering. When a project demands heavy, realistic graphics, I unleash Unreal Engine 5.

• Rust (Bevy)
• C++
• Unreal Engine 5
• Game Physics

Managing the deployment of complex architectures is an art. I use Cargo for deterministic builds and tools like the WiX Toolset to bundle backend, frontend, and embedded modules into a single installer.

• Cargo
• WiX Toolset
• CI/CD
• Deployment

My default for memory safety in complex data structures is Rust. But when I need to manipulate CPU cache lines or write custom memory allocators, I step into C++.

• Rust
• C++
• Algorithm Design

I engineer highly resilient scraping systems that hold up against modern anti-bot mechanisms. TLS fingerprint management and ultra-fast DOM parsing are my standard workflows.

• Python
• Go
• HTTP/2
• DOM Parsing

I hate doing the same thing twice. To reduce operational overhead to absolute zero, I build tools using Python and Go that automate everything from server tasks to headless browsers.

• Python
• Go
• Selenium
• Bash

I write Python for rapid data extraction, and C# to instantly prototype architectural concepts. For highly concurrent daemons running silently forever, I compile directly to Rust or C++.

• Python
• C#
• Rust
• Scripting

I manage the machine learning lifecycle end-to-end. After heavy mathematical training in PyTorch/TensorFlow, I bypass Python's bottlenecks by deploying models to custom C++ or C# inference engines.

• PyTorch
• C++ (TensorRT/ONNX)
• Model Training
• Inference

I build scalable interaction layers over Telegram, Discord, and Spotify APIs. I handle request routing in Node/Python and offload heavy data crunching to Rust.

• Rust
• Node.js
• Python
• Discord API

When official APIs say 'no', I write custom automation protocols. Using Go and Python, I simulate exact human behavior across strict platforms like Twitter and Kick.

• Python
• Go
• Proxy Rotation
• User Mimicry

Taking things apart is just as fun as building them. I use Ghidra to dissect compiled binaries, map hidden architectures, and analyze x86/x64 and ARM environments.

• Ghidra
• Assembly
• x86-64
• ARM
• Binary Analysis

To truly understand how an app behaves, you have to watch its packets. Analyzing TCP/UDP lifecycles with Wireshark and decoding proprietary traffic is a standard part of my debugging workflow.

• Wireshark
• PCAP
• TCP/UDP
• Network Security

I don't limit myself to standard testing frameworks. I write custom C++ tools to profile memory integrity and stress-test APIs, automating the pipeline with PowerShell.

• C++
• PowerShell
• Stress Testing