I'm Nathaniel (graph90), a Software Developer who enjoys exploring how software works by building things from the ground up.

This GitHub is a collection of tools, experiments, simulations, and projects created from curiosity, real problems, and ideas I wanted to explore further. Some projects are tools I actively use, some are learning experiments, and others are prototypes built to understand a concept more deeply.

I enjoy exploring the layers underneath software: how systems execute, how security concepts work, how AI tools can be built privately, and how complex ideas can be turned into interactive experiences.

Anything I find useful, interesting, or fun gets shared here so others can learn from it, improve it, find problems I missed, or use it for their own projects.

• Low-level systems programming and x86-64 Assembly + C integration
• Security research and exploring how software behaves internally
• Runtime binary transformation and experimental techniques
• System programming on Linux / BSD
• Self-hosted AI systems and local LLM tooling
• Privacy-focused software and user-controlled technology
• Interactive learning systems, simulations, and educational tools
• Experimental quantum computing
• Backend and infrastructure engineering

Many of my projects start with a simple question:

"Can I build something that helps me understand or solve this?"

I like combining:

• Math models
• Automation
• AI reasoning
• Simulations
• Real world data

The goal is not always a finished product. Sometimes the goal is understanding a concept deeply by building the thing itself.

• Languages: Python, C, C++, Java, Bash, Lua, x86-64 Assembly
• Platforms: Linux, FreeBSD, MINIX
• Interests: Systems Programming, Security Research, AI, Quantum Computing, Game Development (Roblox)

A collection of tools, simulations, and experiments built from curiosity, practical problems, and ideas I wanted to explore further.

Some projects became tools I actively use. Others are explorations into concepts, technologies, or possible solutions.

Exploring quantum computing concepts through hands-on implementations and educational notebooks.

Projects include:

• Qiskit and PennyLane experiments

• Interactive Jupyter notebooks and tutorials

• Algorithms explored:

  • Deutsch–Jozsa
  • Bernstein–Vazirani
  • Grover's Algorithm
  • Quantum Support Vector Machines

Public notebook collection: Quantum Computing Projects

A multi-stage exploration into binary transformation, x86-64 assembly, and runtime program mutation.

This project started as an experiment to understand how programs can transform their own machine code while maintaining the same behavior. It evolved from a pure assembly prototype into a more reusable C and Assembly system designed for experimenting with runtime mutation techniques.

https://github.com/graph90/metamorphic-engine

The original experiment written entirely in NASM x86-64 assembly.

The goal was to explore how a program could modify its underlying instructions while still producing identical output.

Explored:

• Register shuffling
• Dead code sequences that clean themselves up
• Control-flow variation
• Instruction permutation
• Runtime modification of machine code

Each execution produces the same visible result while the underlying binary structure changes.

https://github.com/graph90/metamorphic-engine-x64

The next iteration evolved the prototype into a reusable C-callable module.

The focus shifted from a single demonstration program into a more flexible framework for experimenting with binary mutation techniques.

Added:

• C and x86-64 Assembly integration

• Runtime mutation of arbitrary memory buffers

• Position-independent design

• Randomized mutation pipeline

• Custom xorshift random number generator seeded through rdtsc

• Additional mutation operations:

  • XOR transformations
  • ADD operations
  • Bit rotations
  • Byte swapping

The project explores how software can transform at the binary level while preserving execution flow, providing a hands-on way to understand low-level program behavior, machine instructions, and runtime modification.

Community response:

• 59 clones + 2 stars within 6 days
• Shared on LinkedIn with 13k+ organic impressions

An interactive terminal-based Docker learning game built in Python.

Created to explore whether technical concepts could be taught more effectively through hands-on simulation instead of traditional tutorials.

Features:

• Missions, XP progression, streaks, and engineer levels

• Simulated Docker workflows:

  • Image management
  • Container lifecycle
  • Logs and debugging
  • Build and deployment scenarios

Repository: https://github.com/graph90/docker-quest

A gamified cryptography learning platform built in Python.

Built to explore how cryptographic concepts could be taught through interaction rather than memorization.

Explores:

• Caesar Cipher
• Atbash Cipher
• Vigenère Cipher
• XOR encryption
• SHA-256 hashing concepts

Features:

• Missions and progression system
• Achievements and unlockable techniques
• Modular cipher engine architecture
• Save system and UI layer

Repository: https://github.com/graph90/crypto-academy

A lightweight 3D Rubik's Cube simulator built from scratch using vanilla HTML, CSS, and JavaScript.

Created as an exploration into 3D rendering, spatial transformations, and interactive simulations without relying on external frameworks or game engines.

The project models the cube using individual cubies and applies matrix-based rotations to recreate real cube movements directly in the browser.

Explores:

• 3D object representation using CSS transforms
• Cubie-based state tracking
• Matrix-based rotations
• Interactive camera controls
• Puzzle state simulation

Features:

• 2x2, 3x3, and 4x4 cube support
• Real-time 3D rendering
• Mouse orbit controls
• Keyboard cube notation:
  • U D L R F B
• Scramble generator
• Move counter
• Timer
• Responsive layout

Built with:

• HTML
• CSS
• Vanilla JavaScript

No frameworks. No dependencies.

Repository: https://github.com/graph90/rubik-cube-3d

A self-hosted AI assistant built with Flask and LangChain.

Created after seeing growing concerns around private conversations and sensitive data being stored by centralized AI providers.

The goal was to explore a local-first alternative where AI interactions stay under the user's control.

Explores:

• Local LLM workflows
• LangChain architectures
• Retrieval-based AI systems
• Private AI tooling

Repository: https://github.com/graph90/private-ai-companion

A utility created to solve a real workflow issue with managing accurate IMDb metadata for Jellyfin libraries.

Built because I needed the tool myself, then shared it so others could solve the same problem.

Repository: https://github.com/graph90/jellyfin-imdb-cli

An AI-assisted Blackjack analysis system built to explore decision engines, probability calculations, and AI-assisted reasoning.

The project combines traditional Blackjack mathematics with an LLM layer that evaluates game situations using calculated inputs such as:

• Basic strategy decisions
• Card counting information
• Probability analysis
• Current game state

Built as a local experiment into how deterministic algorithms and AI reasoning can work together.

The system currently runs locally and was designed with future integrations in mind as suitable APIs and environments become available.

Repository: https://github.com/graph90/BlackJackAi

A persistent SQLite planning and memory backend for local AI agents.

Originally created to improve reliability when running smaller local models, and became a tool used in my own AI workflows.

Explores:

• Long-term agent memory
• Task planning
• Dependency tracking
• Importance and confidence scoring
• JSON-first tool interfaces for AI agents

Tested with local models including:

• Ornith-1.0-9B-Uncensored-Abliterated-GGUF

Repository: https://github.com/graph90/openclaw-store

A privacy-focused browser-based text and data conversion toolkit built from scratch using vanilla HTML, CSS, and JavaScript.

Created to explore data formats, encoding systems, hashing algorithms, and client-side utilities while keeping all processing local to the user's browser.

The live demo runs directly in your browser. For a completely offline experience, download or clone the repository and open index.html locally.

Explores:

• Base64 encoding and decoding
• Binary and hexadecimal conversions
• Unicode and ASCII transformations
• URL and HTML entity encoding
• JSON formatting and validation
• Cryptographic hashing
• Automatic format detection

Features:

• Fully client-side processing
• No uploads
• No tracking
• Offline capable
• One-click copy and download tools
• Responsive interface

Built with:

• HTML
• CSS
• Vanilla JavaScript

No frameworks. No dependencies. No server processing.

Repository: https://github.com/graph90/transcoder

Live Demo: https://graph90.github.io/pages/transcoder.html