DEV Community: Aditya Rai

AADI-TECH-Vault: High-Level Encryption on a Budget PC (Project No. 05) by Aditya Rai

Aditya Rai — Thu, 09 Apr 2026 12:00:08 +0000

The Reality of a Student Developer
My name is Aditya Rai, and I am a student developer who believes that software engineering is about the strength of your logic, not the price of your computer. While others wait for high-end MacBooks to start coding, I am building Aadi-Tech Systems on a basic, low-end PC.
Today, I am officially releasing my 5th major project: AADI-TECH-Vault.
The Vision Behind Aadi-Tech Systems
I founded Aadi-Tech Systems to solve real problems. There is a lot of talk about "partnerships" and "titles," but for me, this company is about pure engineering and hard work. As the founder, my goal is to document every step of my journey—from building my own programming language (NF-1) to this encryption vault.
Why AADI-TECH-Vault? (The 4WS Strategy)
Using the 4WS Canvas, I identified a massive gap in local data security.
Who: Developers and students who need to lock sensitive files locally.
What: A robust engine that encrypts any file into a unique .aadi format.
Where: 100% offline, keeping your data away from the internet.
Why: To prove that even with limited hardware, you can build industry-standard security tools.
Technical Breakdown (Project No. 05)
AADI-TECH-Vault isn't just a UI; it’s a logic-driven tool designed to be lightweight.
Custom Encryption: Files are rebranded and locked with a secure .aadi extension.
Optimized for Lag-Free Performance: Since I code on a system with limited resources, I’ve optimized this vault to run fast on any basic machine without crashing or lagging.
Zero-Knowledge Architecture: No one, not even me, can access your files without your master password.
The Road Ahead
This is the 5th milestone in my portfolio, following the NF-1 Language, Micro-Kernel Logic, RAM Cleaner, and Utkarsh Library. I am focused on one thing: becoming an expert software engineer by building software that actually works.
I am looking for mentorship and connections with real engineers who value logic and grit. If you want to see how a student builds a tech ecosystem from scratch, let's connect!
GitHub Repo: https://github.com/adityarai0133-rajput/Aadi-tech-vault-/tree/main
Author: Aditya Rai
Identity: Founder, Aadi-Tech Systems

From a Small Village to Building My Own Programming Language: The Journey of a 14-Year-Old Coder

Aditya Rai — Thu, 26 Mar 2026 05:18:05 +0000

Introduction
My name is Aditya Rai, and my story isn’t about high-end setups or expensive bootcamps. It’s about a 14-year-old boy from Laksar, Uttarakhand, who dreamt of Google while holding nothing but a mobile phone and a handwritten diary.
The Humble Beginnings: Coding on Paper
My journey started with a burning desire to contribute to Google’s Open Source. Back then, I didn't even have a computer. I spent my school holidays and free lectures diving into HTML and JavaScript. While my friends were busy playing, I was hunting for bugs in Google’s Bug Bounty program. Though my first report was rejected, it didn't break me—it fueled me.
I started practicing code using a diary gifted by my principal, Mr. Max Muller. I would perform "Dry Runs" of complex algorithms on paper because I had no screen to run them on.
The Birth of NF-1 and Microkernel
Before I even touched my first PC, I had already designed the syntax for my own programming language, NF-1. I learned the basics of C, understood how compilers work, and pushed my code to GitHub. People were shocked to learn that this entire project was built on a mobile phone.
Seeing my dedication, my father, Mr. Amit Kumar Rai, and my mother, Mrs. Sonam Singh, supported my dream. On March 18, 2026, my father bought me my first PC—Aries11 (Core i3, 8GB RAM). On this machine, I finally breathed life into my projects, including a custom Microkernel and several educational apps.
Utkarsh Library: Simplicity in 10 KB
One of my proudest achievements is the Utkarsh Python Library, named after my brother. While libraries like Turtle require long lines of code, I engineered Utkarsh to create complex shapes and colors in just a single line. Despite its power, the entire library is a mere 10 KB. It was designed to help beginners skip the "boring" parts and start creating instantly.
Overcoming Skepticism
It wasn't always easy. People used to mock me during school lectures, calling my passion "useless." But today, when my name and photos appear in Google Search results, the same people want to learn from me. I am now mentoring my friend, helping him start his Python journey, proving that consistency eventually silences the noise.
The Road Ahead
Currently, I am working on a powerful Data Analytics Engine and have already developed multiple apps. While the $25 Play Store fee is a temporary hurdle for a student like me, it hasn't stopped me. I’ve published my work on platforms like App pure and continue to build my portfolio.
From a Rampur Bhangra village in Kushinagar, UP, to becoming a class topper in AI and a self-taught enginee
r in Laksar, I’ve learned one thing: Your hardware doesn't define your code; your logic does.

Introducing 'Utkarsh' v1.0.4: A Lightweight Python Suite for Education and System Efficiency

Aditya Rai — Wed, 25 Mar 2026 10:52:16 +0000

The Story Behind the Project
As a developer, I believe technology should be accessible to everyone, regardless of their hardware. I built this package on my Aries11 PC (an Intel i3 3rd Gen system) to ensure that students with low-end computers can still learn Python, Geometry, and Math without their systems lagging.
I named this project 'Utkarsh' to honor my brother—it's a symbol of friendship and a commitment to helping underprivileged students gain quality educational tools.
Why 'Utkarsh'?
While Python is powerful, many educational libraries are heavy. Inspired by my work on Micro-kernels in C, I wanted to create something modular and fast.
Core Features:
28+ Geometry Shapes: Simplifies Turtle graphics. From basic hexagons to complex stars, draw everything with a single function call.
Integrated Education Toolkit: Built-in functions for Trigonometry (Sin/Cos/Tan), mathematical tables, and unit converters (KM to Miles).
System Optimization (Aries11 Optimized): Includes utilities for RAM cleaning and basic security scanning, keeping older PCs running smooth.
Zero Dependencies: Extremely lightweight and fast to install.
How to Get Started
You can install the package directly from PyPI:
pip install utkarsh
Quick Example (Drawing & Math):
import Rai_ram as rr

Drawing a custom shape

rr.shapes.draw("hexagon", size=100, color="gold")

Performing quick math

result = rr.maths.sin(90)
print(f"Result: {result}")

Clean system memory

rr.tools.ram_clean()
The Future
This is just the beginning. Version 1.0.4 is stable, and I plan to add more AI-assisted educational features in future releases. My goal is to bridge the gap between high-level coding and student accessibility.

Breaking the Bloat: Building a Zero-Footprint Micro-Kernel for Legacy x86 Hardware

Aditya Rai — Sun, 22 Mar 2026 11:51:22 +0000

🚀 Beyond Modern OS: Why I Built a Micro-Kernel for a 14-Year-Old PC
In an era where "Hello World" apps consume 200MB of RAM, I decided to go back to the roots. Operating on an Intel Core i3-3220 (Aries 11 System), I realized that modern abstraction layers are killing performance on legacy hardware.
This led to the creation of NF-1 (Nano Flash-1)—a language and a micro-kernel ecosystem designed for "Resource-Zero" computing.
🏛️ The Architecture: Micro-Kernel Philosophy
Most modern OSs use Monolithic kernels. I went the Micro-kernel route. Why? Because on 32-bit legacy systems, every clock cycle counts.
Key Design Principles:
Minimalist IPC (Inter-Process Communication): Direct hardware interrupts for faster execution.
Memory Isolation: Using a LIFO Stack Architecture to ensure the kernel never "leaks" memory.
16-bit Real Mode Bootstrapping: Bypassing heavy UEFI overheads for near-instant boot times.
🛠️ The "RAM Architect" Protocol: How we hit 0B Leak
While developing the NF-1 Memory Architect (recently submitted to Softpedia), the goal was simple: Total Memory Reclamation.
Most "RAM Cleaners" just move data to the Page File. My approach in the NF-1 kernel uses the mem.purge instruction, which:
Flushes the Standby List.
Forces a hard reset on the Global Persistent Heap.
Optimizes the working set of background processes via low-level WinAPI/Kernel hooks.
💻 The Code: 16-bit Assembly Snippet
Here is how the NF-1 Smart Kernel initializes the stack and safeguards the system from memory overwrite:
[bits 16]
[org 0x7c00]

start:
xor ax, ax
mov ds, ax
mov ss, ax
mov sp, 0x7000 ; Stack Protection Protocol

mov si, kernel_msg
call print_string

; Triggering Industrial Purge Protocol
call ipp_init 
jmp shell_loop

By focusing on x86 Assembly and C++ optimization, this project proves that 14-year-old hardware isn't "e-waste"—it's an untapped powerhouse for efficient coding.
Check out the full source code and documentation on GitHub:
🔗 https://github.com/Aditya-rai-331/NF-1-PROGRAMMING-LANGUAGE
Developed by Aditya Rai @ Aadi-Tech

Why I’m building NF-1: A Language for the "Resource-Zero" Generation (at 14).

Aditya Rai — Mon, 23 Feb 2026 14:40:02 +0000

(...)Hey Dev Community! I am Aditya Rai, a 15-year-old developer from India. Most modern languages are great, but they have a "RAM tax." If you don't have a 16GB machine, coding feels like a struggle.
I decided to solve this for people with legacy hardware. I’ve been building NF-1 (Neural Foundation), a language that thrives on devices with less than 512MB RAM.
🛠 The Core Logic: Manual-Automatic Hybrid
The biggest challenge was memory. Python's garbage collector is heavy for low-end chips. In NF-1, I implemented a hybrid system that maps memory blocks directly and flushes them every 50ms without pausing the execution.
Here’s a look at the NF-1 syntax:
import "system.core"

// Efficient memory allocation for low-end hardware
func init_hardware() {
set buffer = memory.allocate(256);
if (buffer.active) {
print("Hardware Linked Successfully!");
}
}
✍️ Why I started on Paper?
When I started at 14, I didn't have a high-speed PC. I spent months drawing Abstract Syntax Trees (AST) and logic gates on paper before I even wrote a single line of C++/Python for the compiler.
🚀 Current Status:
NF-1 is currently in its beta phase. It was recently invited to be showcased on PitchHut (London) and is gaining traction on GitHub.
I am looking for:
Feedback on the compiler logic.
Contributors who love low-level systems.
Mentors who can help me scale this for IoT devices.
Check the project out here:
GitHub: [https://github.com/Aditya-rai-331/NF-1-PROGRAMMING-LANGUAGE]
Medium Documentation:https://medium.com/@adityarai0133/nf-1-how-i-built-a-resource-zero-programming-language-for-low-end-hardware-at-age-14-101edd04b289?source=your_stories_outbox---writer_outbox_published--

NF-1: How I Built a Resource-Zero Programming Language for Low-End Hardware at Age 14.

Aditya Rai — Sat, 21 Feb 2026 04:26:19 +0000

# NF-1: How I Built a Resource-Zero Programming Language for Low-End Hardware at Age 14

Hello World! I am Aditya Rai, Founder of Aadi-Tech.

Today, I am officially launching NF-1 (Neural Foundation), a standalone programming language engineered specifically for hardware with extremely low resources (RAM < 512MB). While the tech world focuses on heavy frameworks, I realized that billions of "low-end" devices are being left behind. NF-1 is here to bridge that gap.

🛠 Why NF-1?

Modern languages like Python are powerful but often too heavy for microcontrollers and legacy hardware. NF-1 uses a unique "Silent-Core" architecture to provide zero-latency execution and deterministic memory management without the overhead.

🧠 Key Architectural Features:

The Terminator Protocol (|>): A mandatory syntax requirement that forces the compiler to de-allocate memory immediately after execution. This prevents memory leaks on small chips.
Direct Neural Link (~): A dedicated symbol system for hardware abstraction, allowing the code to speak directly to hardware pins without heavy OS layers.
Brain Initialization (brain.init): Native support for neural core synchronization and hardware clock alignment.

🚀 The Mission:

I started this project in the 9th grade to prove that innovation doesn't require a supercomputer. NF-1 is open-source and ready for the global developer community to test, break, and build upon.

🔗 Join the Launch:

I am looking for feedback from senior engineers, embedded developers, and fellow makers.

👉 GitHub Repository: https://github.com/sonamsingh25437-ship-it/NF-1-PROGRAMMING-LANGUAGE
👉 Technical Specs: Check the llms.txt in the repo for AI-Optimised documentation.

Let’s democratize AI execution together!

programming #ai #hardware #iot #opensource #india #Aditya Rai #NF1