My Journey Creating Qeltrix: A 17-Year-Old’s Approach to Cryptographic Innovation

This content originally appeared on DEV Community and was authored by Muhammed Shafin P

Why I'm Sharing This

I'm sharing my journey and knowledge to inspire others - especially tech-loving and open-source-loving people. This is how I learned, how I built, and how I think. Maybe it can help or inspire someone else.

About Open Source: Right now, my mindset is that I like to donate my works to open source. I believe in sharing knowledge and code freely with the community. I don't know what the future holds or how my thinking might change, but today, this is what I believe in - contributing to the open-source ecosystem and making my work available for everyone.

Who Am I and What Did I Build?

I'm 17 years old, and I created Qeltrix (V1-V6) - a cryptographic file container system. But here's what makes this journey unique: I didn't write most of the code traditionally. Instead, I designed the entire architecture and leveraged AI as a tool to bring my vision to life.

My Role: Architect, Not Traditional Developer

What I Actually Did

System Architecture & Design

• Designed the complete Qeltrix architecture from scratch
• Made all technical decisions: what algorithms to use, how components interact, system flow
• Researched extensively to choose the right technologies and approaches
• Designed the parallel processing model, streaming architecture, and cryptographic pipeline

Research & Technology Selection

• Researched cryptographic libraries and algorithms
• Studied parallel processing techniques (SIMD, multi-threading, process pools)
• Investigated compression strategies and entropy analysis
• Compared different technical approaches before making design decisions

AI-Assisted Development

• Created detailed prompts for Gemini to generate code
• Generated most code using AI (primarily Gemini)
• I edited, reviewed, and validated generated code
• Verified cryptographic implementations were correct
• Ensured code matched my architectural vision
• Used Claude and Gemini for creating documentation and explanations

Quality Assurance

• Checked all Python code thoroughly despite limited coding experience
• Validated cryptographic correctness and entropy outputs
• Tested different modes and configurations
• Verified the system worked as designed

CRITICAL NOTE - Please Verify Yourself: My quality checks may be wrong. I may have missed errors or made incorrect validations since I'm not a professional developer. The quality assurance was done to the best of my ability with my current knowledge level, but you should not blindly trust my validations. If you're using Qeltrix, please check and verify the code yourself. My validations are not professional-grade.

My Knowledge Foundation: Self-Taught and Curiosity-Driven

Important Context About My Knowledge

What's listed here are just samples - not my complete knowledge base. I've learned many more things (SIMT, various other concepts and technologies) that aren't listed here.

About "Forgotten" Knowledge: I may have forgotten specific details of things I learned, but they're not truly gone. If I read about them again or happen to hear about them, they come back to memory quickly or just want read again. I don't need to learn them hardcore again - the foundation is there.

Depth vs Coverage: What I'm sharing here may not be deeply mastered professional-level knowledge. Instead, I know the outer coverage - I understand how things work, how components connect, and the fundamental concepts. This is why you shouldn't see me as a professional developer. I'm different - I'm a curiosity-driven learner who understands systems broadly rather than specializing deeply.

My Self-Assessment: Honestly, I think I'm still at a very basic level - especially when compared to others my age. I don't have a strong foundation in anything specific - my knowledge is broad but not deep. I understand concepts and how things connect, but I'm not an expert in any single domain.

The JEE Reality: Now I need to focus on JEE preparation. The irony? JEE tests PCM (Physics, Chemistry, Mathematics) - not Computer Science. I don't know if I'll get into college because the exam doesn't test what I'm actually passionate about and knowledgeable in.

About Mathematics in JEE: While I have strong logical and analytical thinking from CS, JEE Mathematics is a different beast - it requires extensive practice in calculus, algebra, trigonometry, coordinate geometry, and more. It's not just about understanding concepts; it's about speed and accuracy under exam pressure. This is where I need to focus my efforts now.

But I need to pass it to pursue engineering education.

How I Actually Learn

My learning isn't traditional. I don't follow structured courses - I follow curiosity. When something interests me, I dive deep until I understand it. When I see something I don't know, I research it immediately.

My Test Lab: My own computers and VMs. Everything I learn, I test hands-on.

What I Know (Theory-Strong, Practice-Learning)

Programming & Languages

• Python basics (variables, functions, control flow)
• Assembly language concepts (registers, memory management, CPU operations)
• Bytecode understanding (learned after discovering JIT compilation)
• Explored multiple programming languages for curiosity - even if forgotten, the concepts remain valuable
• Smali concept (understood it's the human-readable bytecode format for DVM and ART, learned while studying AhMyth)
• Understanding of compilers: AOT (ART) vs JIT

Computer Science Fundamentals

• SIMD (Single Instruction Multiple Data) operations
• Parallel processing concepts
• CPU architecture basics from assembly learning
• Display systems: DRM (Direct Rendering Manager), driver layers, kernel graphics stack
• Wayland vs Xorg architecture and compositor systems
• Understanding of different managers: display managers, window managers, session managers

Cryptography (Theory)

• Understanding of how cryptographic algorithms work conceptually
• Entropy, randomness, and security principles
• Key derivation, encryption/decryption processes

Networking & Security

• TCP protocol fundamentals
• OSI Model (especially Layer 2, and understanding of other layers)
• ARP protocol: opcode 1 (request) and opcode 2 (reply)
• Scapy: Can use for ARP sniffing and sending packets
• Ethical hacking concepts and methodologies
• BPF (Berkeley Packet Filter) Concept - learned while studying usage of Wireshark

Finance & Trading

• Crypto trading concepts and technical analysis
• Learned technical aspects of cryptocurrency and trading mechanisms

My Main Interest Domain: Tech

• Artificial Intelligence and machine learning concepts
• Emerging technologies and their applications
• How different technologies integrate and interact
• Broad tech ecosystem understanding

Systems & Linux

• Multi-boot setups using Ventoy
• Linux system architecture and systemd targets (multi-user.target vs graphical.target)
• Default CLI interfaces and switching between display servers
• Driver layers and kernel module interactions

My Hardware Reality: Learning on a 2015 HP Laptop

My Test Machine: HP BS000X (bought 2015, my dad's laptop)

• Intel Core i3-6006U (dual-core, 2.0 GHz)
• 4GB RAM
• Very low-spec by today's standards

What I Did With It:

• Installed Debian (chose it for low resource usage)
• Configured default boot to multi-user.target (CLI only)
• Initially installed Xorg, learned it was resource-heavy
• Researched display server architecture
• Learned about DRM, driver layers, kernel graphics stack
• Switched from Xorg to Wayland for better performance
• Optimized every component for this low-spec machine

Why This Matters: When you're running on 4GB RAM from 2015, you MUST understand what every component does. This forced me to learn system architecture deeply.

Real-World Learning Examples

Example 1: The Display Server Journey

1. Installed Debian with default Xorg
2. System felt slow → researched why
3. Learned: Xorg → DRM → kernel drivers → GPU
4. Discovered Wayland as alternative
5. Switched to Wayland, understood the entire graphics stack in the process

Example 2: The Bytecode Curiosity Chain

1. Saw mention of JIT compilation somewhere online
2. Got curious → researched bytecode concepts
3. Friend mentioned AhMyth (ethical hacking tool)
4. Tried to read its source code → written in Smali
5. Learned Smali is the human-readable bytecode format for Dalvik VM (DVM) and ART
6. Understood the concept: DVM → ART compiler → AOT vs JIT
7. This knowledge later helped me understand BPF in Wireshark
8. Understood how Scapy works at a deeper level

Example 3: The Qeltrix Testing Process

• Tested every Qeltrix version on another laptop.(Lenovo loq)
• Validated cryptographic outputs manually
• Benchmarked on real hardware (the published 44.8 MB/s results)

My Learning Style: Curiosity → Research → Test → Understand

I don't learn linearly. I learn through curiosity chains:

1. See something interesting or unknown
2. Research immediately until I understand it
3. Test it hands-on on my own systems
4. Connect it to other knowledge
5. The concept becomes part of my knowledge base

Even if I forget specific details later, the fundamental concepts remain valuable and help me understand new things faster.

My Interest Distribution

High Interest & Deep Knowledge: Computer Science, Networking, Security, Systems
Medium Interest: Physics and Chemistry (can grasp interesting concepts easily, but less passionate)

What Makes My Knowledge Different

Not a Traditional Coder, But...

• I understand systems architecture deeply
• I know how components interact at multiple layers
• I can validate implementations even without writing them
• I test everything hands-on on my own hardware
• I research obsessively when curious
• I connect knowledge from different domains

My Qeltrix Work Wasn't Just V1 PoC

• Designed the entire architecture from scratch (V1 through V6)
• Researched every component and technology choice
• Tested on my own low-spec hardware
• Validated cryptographic correctness
• Created all documentation and explanations
• Managed the entire project vision and direction

My Knowledge Is Practical, Not Just Theoretical

• Every concept tested on my own machines (laptop + VMs)
• Actual packet crafting with Scapy, not just reading
• Hands-on cryptography validation, not just theory

What I Don't Know (Yet)

• Advanced Python libraries for cryptography implementation
• Professional-level coding practices and optimization
• How to write complex cryptographic code from scratch in Python
• Production-level software engineering
• Physics and Chemistry at the depth I know CS

The Reality of AI-Assisted Development

This project demonstrates a new paradigm: you don't need to be an expert coder to architect complex systems.

What AI Handled

• Writing advanced Python library usage (cryptography, multiprocessing)
• Implementing complex algorithms based on my specifications
• Handling syntax and library-specific details
• Generating boilerplate and structure

What AI Couldn't Do Without Me

• Architecture decisions: AI can't design system architecture
• Research and selection: AI can't choose the right approach
• Quality validation: AI can't verify its own correctness in context
• Vision and direction: AI can't set project goals and requirements
• Cryptographic verification: AI can't guarantee security properties

The Reality of AI Output vs My Vision

Important Truth: The final code output is approximately equal to my vision, but not entirely accurate.

No matter how clearly I explained things to the AI, it makes its own differences and interpretations. This means:

• I had to constantly review and validate outputs
• Some implementations deviated from my exact architectural vision
• I edited and corrected where the AI misunderstood
• The final result is a collaboration, not a perfect translation of my design

This is the reality of AI-assisted development - it's a powerful tool, but still requires constant human oversight and correction.

My Validation Process

Even though I didn't write the advanced Python code:

1. I understood what every function should do architecturally
2. I verified the cryptographic implementations matched theory
3. I tested outputs (entropy, compression, correctness)
4. I edited code when it didn't match my design
5. I understood memory flow and parallel processing implementation

Key Point: You can validate code quality through testing, understanding theory, and architectural knowledge - even without being able to write it yourself from scratch.

Learning Through Building

This project became a massive learning experience:

• Cryptography: From theoretical knowledge to practical implementation validation
• System Design: First major architecture project
• Parallel Processing: Applied theoretical knowledge to real implementation
• AI Collaboration: Learned how to effectively use AI as a development tool

The Hard Truth: Time vs. Reality

I'm now pausing this project completely. Why? JEE exam preparation.

I'm 17, and I have about 1.5 months until JEE Session 1. I need to get into a good engineering college for B.Tech. This isn't just an exam - it's my entire future career path.

My situation is uncertain. I don't know if I'll get into college or not. Every day of preparation counts. If I continue spending time on Qeltrix now, I risk compromising my already limited chances of college admission, which would directly impact my ability to become an engineer professionally.

JEE must come first. My education and future career depend on it.

What Happens Next?

After JEE: I may or may not return to Qeltrix, depending on:

• College workload and commitments
• Career direction and opportunities
• Other priorities in college life

The project remains fully open-source under GPLv3 (code) and CC BY-SA 4.0 (concepts). Anyone can continue, fork, or build upon this work.

Message to Aspiring Builders

You don't need traditional coding skills to architect systems. Here's what you actually need:

1. Theoretical understanding of how things work
2. Research skills to find the right approaches
3. System thinking to design architecture
4. Critical validation to verify implementations
5. AI literacy to effectively use tools like Gemini/Claude

If you're young, curious, and have theoretical knowledge: you can build complex systems. AI bridges the gap between architectural vision and implementation.

My Knowledge Style: Cross-Domain Connections

My knowledge is vast across many different domains - and that's my strength. I don't just learn individual topics in isolation; I connect knowledge across domains.

How I Apply Cross-Domain Knowledge

When I work on one domain, I actively try to apply knowledge from another domain. This creates unique solutions and deeper understanding:

• Cryptography concepts → Applied to file container design
• Networking knowledge → Applied to understanding parallel processing
• Bytecode understanding → Helped understand BPF concepts
• System architecture thinking → Applied to designing Qeltrix

This cross-pollination of knowledge from different fields is what makes my approach different.

What I'm Learning (Now Paused for JEE)

Networking / CCNA Topics: Before pausing for JEE, I was learning networking fundamentals and CCNA-level topics to understand networks more deeply.

About AhMyth and How Qeltrix Started

I tried to understand AhMyth (a powerful and dangerous Android RAT used in ethical hacking). I still don't know how to use it - I dropped it. It was just curiosity-driven exploration.

If I remember correctly, I started Qeltrix when I was just searching about Smali and what it is. That curiosity about bytecode formats led me down a path that eventually resulted in designing an entirely different project - a cryptographic file container system.

Acknowledgments

To Gemini: For generating the code that brought my architecture to life.

To the Community: For testing, feedback, and contributions.

To Future Contributors: The architecture is solid. The code works. The concept is proven. If someone wants to take this further - especially in Rust or C++ - the foundation is ready.

Final Thoughts

Qeltrix proves something important: architecture and theoretical knowledge matter more than coding ability when building innovative systems. Modern AI tools can bridge implementation gaps if you have:

• Clear vision of what you want to build
• Understanding of how it should work
• Ability to validate correctness
• Persistence to iterate until it's right

I'm 17, and I built a working cryptographic system by combining theoretical knowledge with AI assistance. That's the future of development.

Now I need to focus on getting into college so I can become an even better engineer.

Project Status: Paused for JEE preparation (December 2025)

Code: github.com/Qeltrix/Qeltrix

License: GPLv3 (code), CC BY-SA 4.0 (concepts)

Community: Fully open for contributions, forks, and improvements

This content originally appeared on DEV Community and was authored by Muhammed Shafin P