Harshwardhan Patil

independent engineer · systems · security · intelligence

I work at the intersection of software, systems, security, and computational intelligence. I'm interested in understanding how computing systems work beneath their abstractions — from machine instructions, memory, and kernels to networks, distributed infrastructure, and intelligent models.

My approach is to understand by building. Architect the system, implement its components, inspect its internals, break things deliberately, and understand why they break. I move between abstraction layers, following dependencies rather than treating technologies as isolated subjects.

I don't believe meaningful expertise comes from starting everything at zero or mastering every layer in isolation. My approach to learning and engineering is graph-based: establish solid primitives, connect adjacent concepts, build a working mental model, and progressively explore deeper into the underlying substrates and higher-level abstractions.

The objective is not simply to use technology, but to understand it well enough to redesign, extend, optimize, and build it independently.

Long-term, I'm drawn toward the intersection of software and physical computation — operating systems, computer architecture, embedded systems, hardware-software interaction, and intelligent machines.

Focus Areas

Systems & Computer Engineering

Operating systems, Linux internals, kernel development, computer architecture, memory management, concurrency, compilers, and systems programming. Exploring how software interacts with processors, memory, hardware interfaces, and the underlying machine.

Cybersecurity & Systems Research

Binary analysis, reverse engineering, vulnerability research, network security, exploit development, and security automation. Understanding how systems fail, how vulnerabilities emerge, and how to engineer stronger security boundaries.

Networking & Distributed Infrastructure

Network protocols, socket programming, distributed systems, virtualization, container internals, and infrastructure engineering. Understanding how independent machines communicate, coordinate, scale, and recover from failure.

Artificial Intelligence & Computational Intelligence

Neural networks, deep learning, transformers, local LLMs, RAG architectures, and machine learning systems. Exploring the mathematical and computational foundations of intelligence, from model architectures and training to inference, optimization, and deployment.

Mathematics & Algorithms

Discrete mathematics, linear algebra, probability, numerical methods, data structures, algorithms, and computational complexity. Studying the theoretical structures beneath software and the mathematics that makes complex systems possible.

Embedded Systems & Hardware-Software Interaction

Microcontrollers, computer architecture, embedded programming, firmware, real-time systems, and hardware interfaces. Exploring the boundary between computation and the physical world — where software meets electronics, sensors, and machines.

Engineering Direction

My long-term direction is toward becoming an independent systems engineer and researcher — capable of moving across the computing stack, from low-level software and hardware interfaces to distributed infrastructure and intelligent applications.

I want to develop the ability to:

  • → Engineer systems from the ground up: Design operating-system components, kernels, runtimes, developer tools, and infrastructure.
  • → Understand machines at the lowest practical level: Work with C, assembly, memory, processors, instruction sets, and hardware interfaces.
  • → Investigate and secure complex systems: Analyze binaries, discover vulnerabilities, understand attack surfaces, and develop defensive tooling.
  • → Build networked and distributed software: Design protocols, servers, storage systems, and resilient infrastructure.
  • → Develop computational intelligence: Implement neural networks, explore model architectures, and engineer efficient AI inference systems.
  • → Bridge software and physical systems: Explore embedded computing, firmware, microcontrollers, and hardware-software co-design.
  • → Build independently: Turn research, ideas, and technical understanding into functional, modular, and open-source products.

The ambition is to move beyond being a consumer of abstractions and become someone capable of understanding and engineering the abstractions themselves.

Stack & Environment

Languages Python · C · C++ · Bash · x86-64 Assembly
Systems & Operating Environments Linux · Arch Linux · Hyprland · Operating Systems · Kernel Development
Networking & Infrastructure TCP/IP · Socket Programming · Docker · Kubernetes · Proxmox · Virtualization · Distributed Systems
Security & Engineering Tools GDB · Ghidra · Wireshark · GCC · Clang · Git · Linux Tracing Tools
AI & Computational Tools PyTorch · NumPy · Ollama · Local LLMs · RAG · GPU Computing
Workflow & Knowledge Git · Obsidian · Terminal-Centric Workflows · Technical Writing · Research Documentation

The stack is an evolving toolkit, not a fixed inventory. Tools are selected according to the problem, not the other way around.

Operating Principles

Navigating uncertainty through evolving frameworks rather than rigid, immutable rules. Understanding is provisional; models improve as evidence accumulates.
Freedom over Constraint
Maximizing degrees of freedom. Systems should enable autonomous exploration, experimentation, and rapid iteration rather than trapping their users in artificial dogmas.
Thought becomes debuggable when it is externalized. Writing is not merely documentation; it is a mechanism for structuring ideas, exposing contradictions, and refining mental models.
Graph-Based Growth
Progress is node-to-node traversal. Establish reliable primitives, understand their relationships, follow dependencies, and expand into adjacent domains. Build depth where necessary without losing sight of the larger system.
First Principles, Then Abstraction
Understand the underlying mechanism before depending on the abstraction. Learn what a tool hides, what it guarantees, and where its boundaries fail.
Build, Break, Understand
Theory provides the model; experimentation tests it. Build deliberately, inspect failures, investigate their causes, and use the resulting knowledge to engineer better systems.