Software engineer / multidisciplinary builder

ByteAshen

Software Hardware Homelab Art

I build and take apart software, hardware and infrastructure—from low-level systems to the physical devices and networks they run on. Clean interfaces, observable behaviour, and engineering that survives contact with reality.

Explore my work See the homelab

C++ and native systems Network engineering Automation-first infrastructure Hardware builds & 2D/3D art

Selected work

One real project. More when they are ready.

Shipped work with source code you can inspect.

Open sourceC++23 / browser automation

CDP for C++

A modern C++ library for Chrome DevTools Protocol automation, ranging from quick one-liners to direct protocol control—without dragging in an external runtime or package ecosystem.

Project breakdown

Problem: Native C++ browser automation often means heavy bindings, generated wrappers, or handing control to another runtime.
Decisions: Zero external dependencies, thread-safe internals, isolated browser contexts, and three API levels for quick, high-level, or raw CDP access.
Capabilities: DOM and input automation, screenshots and PDFs, network interception, request mocking, extension loading, and concurrent sessions.

View repository C++23 · CMake · Windows / Linux

quick_start.cpp

#include <cdp/CDP.hpp>

auto browser = cdp::quick::launch();
auto page = browser->newPage(
    "https://example.com");

page->waitForSelector("#content");
page->screenshot("page.png");

C++ APICDPChrome

RoadmapFuture work

More projects coming soon.

New projects will appear here as they’re finished and documented.

Source code Technical decisions Real results

Follow on GitHub Updates land here first.

About me

Low-level curiosity. Infrastructure-scale thinking.

I’m ByteAshen — a software engineer and full-time tinkerer. Systems programming and homelab infrastructure take up most of my time, but the same curiosity spills into reverse engineering, hardware builds, protocol design and 2D/3D art.

I care about explicit behaviour, useful observability and designs that remain sane after the demo is over — whether that demo is a service, a circuit, or a render.

Start a technical conversation

Reliability before theatre

The clever solution is worthless when nobody can debug it at 02:00.

Automate repeated pain

Manual steps become documentation, then scripts, then boring infrastructure.

Own the whole path

From code and operating systems through switching, routing and deployment.

Also building

Building goes beyond the terminal.

Different tools, same instinct—take it apart, understand it, put it back together better.

Software

Systems & native apps

C++, Rust and the low-level tooling that sits close to the metal.

Infrastructure

Homelab

A self-hosted platform I run and maintain—full breakdown below.

Analysis

Reverse engineering

Pulling binaries and protocols apart to see how they actually work.

Physical

Hardware

Building and modifying real devices, not just the software running on them.

Design

Protocols

Designing and implementing protocols instead of just consuming someone else’s—OpenBuild, a closed-source OpenWRT wrapper, is one example.

Creative

2D & 3D art

Digital art and modelling, away from the terminal.

Skills / stack

Tools backed by actual use.

Grouped by where each one fits in the system.

LanguagesC++, Rust, Python, Go, Luau

C++RustPythonGoTypeScriptJavaScriptLuau

SystemsLinux and native tooling

LinuxBashPowerShellWin32Direct2D

NetworkingProtocols and diagnostics

TCP/IPDNSBGPWiresharkNetfilterOPNsensePFsenseOpenWRTOpenBuild

InfrastructureVirtualisation and containers

ProxmoxHyper-VVMwareDockerKVMLXCZFS

AutomationRepeatable operations

AnsibleTerraformGitHub ActionsMakeGitGrafana

Daily driver

C++ & Linux

Native applications, low-level tooling and systems work where ownership matters.

Advanced

Networking

Routing, switching, DNS, packet analysis and making opaque behaviour observable.

Strong

Automation

Repeatable infrastructure, deployment workflows and removing fragile manual steps.

Working depth

Virtualisation

Proxmox, containers, storage and the operational trade-offs around them.

guest@byteashen:~$ status → shipping C++ · routing packets · automating the homelab

Homelab / infrastructure

A small platform, treated like a real one.

TopologyCore architecture

Edge security

OPNsense

Segmentation, policy and visibility at the boundary.

Compute

Proxmox VE

Virtual machines and containers on a managed cluster.

Storage

ZFS-backed NAS

Snapshots, checksums and deliberate backup paths.

Observability

Metrics & logs

Enough context to diagnose failures instead of guessing.

Representative servicesWhat’s actually running

Proxmox VEVirtualisation and orchestration

TrueNASStorage, snapshots and replication

Pi-holeDNS filtering and local resolution

Home AssistantLocal automation and integrations

ResilienceDesign principle

N+1 where failure hurts

Redundancy is applied selectively: critical services, storage paths and recoverability get attention before vanity metrics.

Documented recovery paths
Snapshots plus separate backups
Segmented service networks

Network designTraffic paths

Core: 10GbE switching
Policy: VLAN segmentation
Visibility: DNS and flow telemetry

Let’s connect

Have a difficult system to untangle?

Projects, infrastructure, networking, or a technically interesting conversation—I’m listening.

Start a conversation