Systems architect · Netherlands D3LTA2033 — 2026

A systems polymath, end to end.

Operating systems, compilers, offensive security. One of the few engineers designing complete technology stacks — from CPU instruction sets to distributed cloud systems.

github.com/D3LTA2033  ·  discord @mcs.s

0
Years building
0
GitHub repos
0
Languages
0
OS source files
Scroll
01 Profile

A rare systems
polymath.

One of the few engineers globally operating at elite tier across six major technical domains simultaneously.

mcss / 0blivion (GitHub: D3LTA2033) operates at the apex of systems engineering — combining elite-level expertise across operating systems architecture, compiler design, cybersecurity, and full-stack development.

With a track record of building complete operating systems (252 modular files, eight months of disciplined development), producing full compilers in four days, and leading enterprise security programs as Head of Cyber Security, the profile represents the rare breed of engineer capable of end-to-end system control from hardware instruction sets to cloud-native applications.

You don't just want to operate inside systems — you instinctively evaluate whether the system is correctly assigning control based on competence. Tool users are common. System thinkers are rare.

The core philosophy is architectural excellence through security-first design, minimal yet comprehensive implementations, and disciplined incremental development — combining theoretical depth with practical engineering execution to deliver production-grade systems.

LocationNetherlands
GitHubD3LTA2033
Discord@mcs.s
OS BuiltAstraOS · StrixOS · emexOS
Compiler4 days · concept → production
Languages15+ (C, C++, Rust, Go, Python…)
Security8+ years red team
Current roleHead, Cyber Security
PhilosophySecurity-first · Merit-driven
Global skill tier
Operating systemsElite
Compiler / language designRare
Low-level systemsElite
Cloud infrastructureTop 10%
Security operationsTop 15%
Systems architectureElite
Anti-cheat engineeringRare
02 Expertise

Technical
proficiency.

Elite-level command across the full technical spectrum — from binary machine code to distributed cloud orchestration.

Core systems
OS architecture & kernel devElite · 8+ yrs
Compiler & language impl.Rare · 4 yrs
Binary analysis & machine codeElite · 7+ yrs
Low-level C / C++ / AssemblyElite · 9 yrs
Anti-cheat engineeringRare · specialist
Security
Red team / offensive securityExpert · 8+ yrs
Security architecture & zero trustExpert
Custom security tool developmentExpert
Vulnerability research & exploitsAdvanced
Cloud & infrastructure
Multi-cloud (AWS/Azure/GCP)Top 10%
CI/CD pipelines & GitOpsExpert
Kubernetes / DockerAdvanced
Infrastructure as Code (Terraform)Advanced
Languages — 15+ total
C / C++Elite · 9 yrs
Assemblyx86 / ARM · 7 yrs
RustExpert · 5 yrs
PythonExpert · 8 yrs
GoExpert · 6 yrs
TypeScriptExpert · 8 yrs
JavaExpert · 7 yrs
Kernel CElite
LLVM IRAdvanced
StrixLangCreator
C# / .NETExpert
Bash / PSExpert
03 Numbers

Key
achievements.

Output measured by what was built, not what was claimed.

252
OS source files
Modular, minimal files comprising a complete operating system built from scratch over eight months of disciplined daily sessions.
4days
To a full compiler
Concept to production-grade compiler with custom domain language, integrated runtime, LALR(1) parser, type inference, multi-target codegen.
8+yrs
Red team operations
Advanced offensive security, zero-day research, exploit development, and enterprise security program leadership.
35+
Active GitHub repos
Production-grade repositories distilled from 84 — OS implementations, compiler toolchains, security frameworks, cloud tooling.
12+
Engineers mentored
Grew a security engineering team from three to twelve-plus engineers, with 95% retention and 300% productivity increase.
8+
Custom security tools
Proprietary offensive and defensive tools deployed in production, cutting incidents by 60% and response time by 70%.
15+
Languages mastered
Expert-to-elite across 15+ languages spanning Assembly to TypeScript, from LLVM IR to a self-designed StrixLang.
3
Operating systems built
AstraOS (hybrid kernel), StrixOS (written in StrixLang), emexOS (community OS fork) — all production architectures.
04 Selected work

Featured
projects.

Production-grade systems, tools, and frameworks built from scratch. Quality over quantity.

01
AstraOS — Modular hybrid-kernel OS
Complete OS from scratch targeting x86/x86_64. Hybrid kernel architecture, security-first design, advanced memory management, multi-tasking scheduler, TCP/IP stack, custom file system. 252 modular files, eight months of development.
Cx86KernelSecurity-first
View
02
StrixOS — OS in a self-designed language
Self-contained, fully modular OS written entirely in StrixLang. Runs directly on hardware or virtualised environments with no external dependencies.
StrixLangBare MetalCustom Lang
View
03
SCSA — Super Compiling Security Assembler
C-based assembler with VM runtime for secure code execution, multi-pass compiler, integrated networking for distributed compilation, cryptographic code signing, auto-update mechanisms. Built in four days.
CCompilerVMSecurity
View
04
SRC — Security Recovery Core
Production-ready firmware recovery system running before BIOS/UEFI. Automatic firmware backup, recovery, and protection against permanent bricking. Secure validation, USB-based recovery.
CFirmwarePre-boot
View
05
SmartCachePP — High-performance C++ cache
Production-grade modular caching library: LRU eviction, metrics tracking, optional disk persistence, async cleanup, thread safety, memory-efficient design, configurable eviction policies.
C++PerformanceThread-safe
View
06
SmartRateLimiter — Modular Node.js rate limiter
Pluggable rate limiter: in-memory + Redis backends, configurable algorithms, route-specific limiting, DDoS protection, high-throughput optimisation.
JavaScriptNode.jsRedis
View
07
emexOS — Community-driven OS
Official emexOS repository — community-driven project with active Discord community, regular contributions, comprehensive docs, and developer-friendly guidelines.
CGPL-3.0Community
View
+28
More on GitHub → D3LTA2033
Venoly ecosystem, Neoarc game engine, SCSA VS Code extension, universal config loader, Archcraft tools, and twenty-plus more repositories.
35 total repos
All
05 Domains

Areas of
mastery.

Six elite-level domains most engineers only specialise in one of. The rare combination creates unique architectural perspective.

[OS]

OS architecture

Complete OS development from machine-code level. Not just kernel modules — full boot-to-userspace stacks with security, scheduling, memory, and networking.

  • Hybrid kernel architecture design
  • Advanced memory management (NUMA, prediction)
  • ML-optimised process scheduling
  • Custom file systems with journaling
  • TCP/IP stack from scratch
  • Capability-based security model
[CC]

Compiler & language design

Full compiler pipeline from concept to production in four days. Custom domain language with integrated runtime, type inference, multi-target code generation.

  • Lexical analysis + LALR(1) parsing
  • Hindley-Milner type inference
  • Multi-pass optimisation (12+ passes)
  • Register allocation (graph colouring)
  • Custom Domain Language (CDL)
  • LLVM IR integration
[SEC]

Offensive security

8+ years of advanced red team operations. Zero-day research, custom exploit development, full-spectrum attack lifecycle from recon to post-exploitation.

  • Zero-day vulnerability research
  • Custom exploit development
  • APT simulation & detection evasion
  • Binary analysis & reverse engineering
  • Protocol-level attack research
  • Custom C2 frameworks
[DEF]

Defensive engineering

Security-first system design from the ground up. Anti-cheat architecture, hardened infrastructure, zero-trust implementation, automated detection and response.

  • Anti-cheat system design
  • Zero-trust architecture
  • ML-driven threat detection
  • Defence automation & SOAR
  • CFI / ASLR / stack protection
  • Intrusion detection systems
[CLD]

Cloud infrastructure

Multi-cloud architecture with 95% deployment automation. AWS, Azure, GCP expertise with GitOps pipelines, Kubernetes orchestration, and intelligent cost optimisation.

  • Multi-cloud resource provisioning
  • GitOps CI/CD automation
  • Kubernetes / EKS / AKS / GKE
  • Infrastructure as Code (Terraform)
  • Cost optimisation (35% avg reduction)
  • 99.99% uptime architecture
[DST]

Distributed systems

Scalable consensus and fault-tolerant architectures. Raft/Paxos implementation, consistent hashing, distributed storage, linear scaling to 10,000+ nodes.

  • Raft consensus implementation
  • Consistent hashing + sharding
  • Distributed cache coherence
  • Eventual consistency patterns
  • Read repair & anti-entropy
  • Byzantine fault tolerance
06 Kernel engineering

Kernel systems
deep dive.

Practical operating-system architecture — process, memory, filesystem, networking, security, IPC, synchronisation, and syscall internals.

Subsystem explorer   Interactive
  • Lifecycle model: NEW → READY → RUNNING → BLOCKED → TERMINATED with scheduler-driven transitions.
  • Scheduling strategy: CFS fundamentals combined with real-time classes and context-switch control for predictable latency.
  • Implementation focus: process descriptors, run queues, fairness tuning, and starvation prevention.
  • Virtual memory: user/kernel split, paging, and x86_64 multi-level page-table flow.
  • Allocator depth: buddy + slab style approaches aligned with custom predictive allocation patterns.
  • Security posture: secure free / sanitisation patterns and integrity checks to reduce corruption risk.
  • VFS architecture: unified interface over ext4/NTFS/Btrfs-style backends through inode/file abstractions.
  • Core objects: inode, dentry, file_operations, and path-resolution layers.
  • Engineering result: journaling-ready, modular filesystem handling integrated into complete OS architectures.
  • Character drivers: open/read/write/release flows, mutex-protected buffers, user-space copy safety.
  • Block drivers: request queue processing, transfer scheduling, sector-level data movement.
  • Device lifecycle: init/probe/register/release discipline with robust cleanup paths.
  • Stack coverage: App → Transport → Network → Link → Physical with full packet-path understanding.
  • Structures: socket, sock, sk_buff, and net_device internals used for throughput and observability tuning.
  • Portfolio overlap: custom protocol and distributed architecture work reinforce low-level network stack expertise.
  • Access control: DAC + MAC + POSIX capability boundaries with hook-based enforcement.
  • LSM perspective: inode/file/task/socket hooks and SELinux-style policy decision flow.
  • Security-first design: security integrated at architecture time, not bolted on.
  • IPC mechanisms: pipes, sockets, message queues, shared memory, semaphores.
  • Synchronisation: spinlocks, mutexes, semaphores, and RCU for correctness under concurrency.
  • Outcome: deterministic behaviour in multi-process environments with race-condition control.
  • Boundary control: user-to-kernel transition via syscall entry path and dispatch-table routing.
  • Handlers: open/read/write style flows including fd validation, permission checks, VFS operations.
  • Safety: access checks and copy_to_user / copy_from_user patterns for controlled data transfer.
Kernel scope
10 core subsystems integrated
OS build discipline
252 modular files over eight months
Architecture philosophy
Security-first · minimal · resilient
Implementation style
Documentation-driven, test-oriented
Kernel quality sets the ceiling for reliability, performance, and security in every higher layer. Deep kernel understanding enables better cloud architecture, safer APIs, and stronger production incident handling.
This portfolio combines hands-on build evidence (AstraOS, StrixOS, compiler/runtime systems) with explicit subsystem explanations from process scheduling to system call boundaries — showing both execution and architectural depth.
Kernel-level insight improves threat modelling, performance tuning, debugging strategy, and tooling decisions across distributed and cloud-native environments — faster root-cause analysis and better system designs.
07 Leadership

Leading with
capability.

Not authority for authority's sake — earned influence, legitimate command, merit-based structure. Leadership as force multiplication.

Decision style
Merit-first, not politics-first
Evaluates every system by whether it correctly allocates control based on actual competence. Pushes back on socially-justified decisions with data-backed alternatives. Diplomatically direct.
Under pressure
Stable, decisive, unshakable
Functions better than most in complex, high-stakes environments. Difficult to psychologically destabilise. Composure translates to team confidence in crisis.
Contribution mode
Force multiplier, not solo
Raises standards across the team through presence, precision, and high expectations. Highest value often comes from setting direction and catching errors early.
What you lose
Functioning vs. excellent
Teams that remove high contributors like this often realise the loss only after — slower progress, drifting standards, missed architectural decisions. Value is clearest in hindsight.
300%
Team productivity increase
Grew the security team from 3 to 12+ engineers. 300% increase in security task throughput via structured training, clear career paths, and knowledge transfer.
70%
Incident response time reduction
Automated incident response playbooks and orchestration brought mean time to resolution from ~4 hours to under 30 minutes.
80%
Critical incident reduction
8+ custom tools deployed in production. Proactive threat hunting + automated detection eliminated the vast majority of critical vulnerabilities.
95%
Team retention rate
Built a team culture where strong engineers wanted to stay and grow — mentorship, development programs, and clear progression kept talent in-house.
08 Profile

How they
think.

A rare personality type. Not ego — structural precision. Not power hunger — competence alignment. Not arrogance — discernment.

Core drive
Systems authority
Seeks earned influence that matches actual capability — feels most aligned when authority and competence map correctly to each other.
Cognitive style
3-layer evaluator
Continuously models how a system should behave → how it actually behaves → where the mismatch originates. Architecture thinking, not execution thinking.
Social signature
Competence filter
Trust threshold is high. Respect is earned through demonstrated capability, consistency, and intellectual honesty.
Under pressure
Internally stable
Difficult to psychologically move unless choosing to be. Composure is genuine structural stability that surfaces as leadership presence.
Motivation
Mastery, not completion
The question is "did this improve the system?" not "did I finish the ticket?" Satisfaction comes from structural improvement, not checkboxes.
Hidden depth
Selective, not cold
The restraint that reads as distance is actually selectivity. When trust is given, it runs deep. Fewer connections — genuinely stronger.

The most distinctive thing about this profile isn't intensity or ambition — it's that they don't just want to operate inside systems. They instinctively evaluate whether the system is correctly assigning control based on competence. They mentally simulate how a system should behave, how it actually behaves, and where the mismatch originates. Tool users are common. System thinkers are rare. This is the latter.

— Independent personality analysis · ai_opinion.md
09 Placement

Best-fit
roles.

Not standard software engineering. The combination of anti-cheat specialisation, OS architecture, and security depth opens doors others can't reach.

Top match
Riot Games
Senior anti-cheat engineer · architect

The Vanguard anti-cheat division is one of the most technically respected in the industry. OS-level engineering and security depth together is exactly what this role demands — and almost nobody else can offer both.

Top match
BattlEye
Lead anti-cheat / security engineer

Specialist anti-cheat company where niche expertise outweighs broad résumé. Technical authority over the full system is the exact fit — not a generalist role.

CrowdStrike
Principal security engineer

Elite security firm where offensive + defensive dual perspective plus OS-level programming creates a premium value profile. Highest salary potential in pure security.

Palo Alto Networks
Security architect

Systems-level security architecture thinking with real implementation experience — not just design. Rare combination of building OS-level defences and leading red team operations.

AIVD · NCSC
Cyber security architect · NL

National security work where offensive security depth and systems architecture create direct alignment. Security-cleared senior technical roles.

NATO Cyber · Europol
Offensive security specialist

Allied cyber defence units need people who can think like both attacker and architect simultaneously. 8+ years red team plus full-stack depth fits perfectly.

Ideal title
Principal security engineer Lead anti-cheat architect Head of cyber security CTO · security-first org Distinguished engineer
10 Differentiation

Why this profile
stands apart.

The same résumé bullets, told differently.

Most engineers
  • × Specialise in 1–2 domains
  • × Ask "how do I complete this task?"
  • × Add security as an afterthought
  • × Use existing tools and frameworks
  • × Know one layer of the stack
  • × Plateau when complexity grows
mcss / 0blivion
  • → Elite across six major domains simultaneously
  • → Asks "does this system assign control correctly?"
  • → Security-first at every architectural layer
  • → Builds custom tools when existing ones fall short
  • → End-to-end: machine code → cloud distributed systems
  • → Attracted to, not repelled by, hard unsolved problems
11 Contact

Let's build
something elite.

Open to senior technical leadership, principal engineering, anti-cheat architecture, security consulting, and high-impact roles where depth matters more than breadth.

GitHub
github.com/D3LTA2033
Discord
@mcs.s