DEV Community: Sachitt A V

I Built a Local-First AI Operating System With 296,000 Lines of Code. Alone.

Sachitt A V — Sat, 25 Jul 2026 07:39:19 +0000

**No cloud. No API keys. No subscription. Just a laptop, an RTX 5070, and 30 days.**

---

Most AI products today are wrappers around OpenAI's API. I wanted to build something different -- an operating system where the AI runs on your own machine, generates 3D models from phone videos, has conversations through voice, and improves itself while you sleep.

I call it **CODA** -- Connected Operating System for Multimodal Intelligent Computing.

Here's what 296,000 lines of code looks like when one person builds it.

---

## The Problem I Was Solving

Every "AI assistant" today has the same three problems:

1. **It needs the internet.** No WiFi, no AI.
2. **Your data leaves your machine.** Every prompt, every voice command, every file -- sent to someone else's server.
3. **You're renting intelligence.** $20/month for ChatGPT, $100/month for Claude Teams, and you still don't own anything.

I wanted an AI that lives on my laptop. One I could train, modify, and break without asking permission.

---

## What CODA Actually Is

CODA is 25+ components that together form a complete AI operating system:

```
BHAASM (2.2B neural brain)
    |
    +-> CODA OS (5 interfaces: desktop, mobile, web, Electron, Next.js)
    +-> CODA Forge (turn phone videos into 3D-printable human models)
    +-> CODA Genesis (generate images, videos, and 3D from text)
    +-> VIJAY (voice assistant with 33 tools, runs locally)
    +-> COSMIC (10 composable device projects)
    +-> Cloud GPU training (Kaggle, Modal, Colab, Lightning -- all free tiers)
```

The key insight: **each component works standalone**. You can use just the 3D scanner, just the voice assistant, or just the neural brain. But when you connect them, something interesting happens.

---

## The Neural Brain: BHAASM

The core is a 2.2 billion parameter transformer I built from scratch. Not a fine-tuned LLaMA -- I mean from random weights to working model.

**Architecture:**
- **RoPE** (Rotary Position Embeddings) -- the model understands position in sequences
- **GQA** (Grouped Query Attention) -- efficient attention without wasting memory
- **SwiGLU** -- gated feed-forward that actually learns
- **MoE** (Mixture of Experts) -- 8 experts, top-2 routing, shared expert for common patterns
- **LoRA adapters** -- AGNI (creative), VEDA (analytical), Generation (prompt refinement)

The model trained on free cloud GPUs. Kaggle gives you 30 hours/week of T4 for free. Modal gives you $30/month of credits. I round-robined between them.

**Training stats:**
- Base: 1.1B TinyLlama, grown to 2.2B via depth-stacking
- Healed on 50K curated records (loss: 0.35 -> 0.008)
- AGNI adapter: creative task routing
- VEDA adapter: safety validation and analysis
- Generation adapter: prompt refinement for image/video/3D generation

---

## CODA Forge: Phone Video to 3D Model

This is the project I'm most proud of.

**The pipeline:**
1. Record yourself rotating 360 degrees with your phone
2. Feed the video into CODA Forge
3. Get a textured, watertight 3D model back

**17 stages:**
- Quality check (lighting, blur, motion)
- Frame extraction (adaptive sharpness selection)
- Temporal consistency (optical flow + landmark smoothing)
- Depth estimation (Depth Anything V2 or MiDaS)
- Scale estimation (automatic metric scale from body proportions)
- Camera calibration (chessboard + EXIF + fallback)
- COLMAP SfM (camera pose estimation)
- Neural reconstruction (ECON, PIFuHD, SMPL-X)
- Face reconstruction (MediaPipe + FLAME)
- Gaussian splatting (optional neural rendering)
- Mesh fusion (Poisson + alpha shape)
- Texture baking (xatlas UV + multi-view blending)
- Export (GLB, OBJ, STL -- 3D print ready)

**The output is a real, 3D-printable mesh.** Not a point cloud, not a depth map -- a watertight mesh with textures.

---

## VIJAY: Voice That Actually Works

Most voice assistants need the cloud. VIJAY runs locally:

- **VAD** (Voice Activity Detection) -- knows when you're speaking
- **Whisper** (STT) -- OpenAI's speech-to-text, running locally
- **Edge TTS** -- Microsoft's text-to-speech, no API key needed
- **33 tools** -- system commands, web search, app control, screenshots, WhatsApp

The wake word is "Hey VIJAY." It listens continuously, processes locally, and responds through your speakers.

---

## The Self-Improvement Loop: TRISHUL

CODA doesn't just run -- it improves itself.

**TRISHUL** (Transcendent Recursive Intelligent Self-improving Holistic Unified Learning) is a training loop:

1. **Generate** -- AGNI creates output (image, video, 3D, code)
2. **Evaluate** -- VEDA scores it, CLIP compares quality
3. **Improve** -- weak outputs become training data
4. **Retrain** -- LoRA adapters update on free cloud GPUs

The system literally gets better while you sleep. I wake up to new checkpoints and curated training datasets.

---

## The COSMIC Ecosystem

10 composable projects that form a virtual device:

| Project | What It Does |
|---------|-------------|
| Cosmic Explore | 3D codebase intelligence -- navigate code as a graph |
| Cosmic Voice | Local voice pipeline (STT + TTS) |
| Cosmic Vision | Gesture recognition + hand tracking |
| Cosmic Canvas | Sketch-to-3D generation |
| Cosmic Core | AI operating system shell |
| Cosmic Flow | Visual pipeline builder |
| Cosmic Atlas | 3D code navigation |
| Cosmic Debug | Visual debugger |
| Cosmic Connect | Service registry + discovery |
| Cosmic Shield | Supply chain security scanning |

Each one is a standalone tool. Together, they form something resembling an operating system.

---

## Tech Stack

```
AI/ML        PyTorch, HuggingFace, LoRA, MoE, BPE Tokenizer
3D Recon     COLMAP, ECON, PIFuHD, Gaussian Splatting, TripoSR
Generation   Stable Diffusion XL, AnimateDiff, I2V, NIM FLUX
Voice        Silero VAD, faster-whisper, edge-tts, MediaPipe
Web          FastAPI, Next.js 16, React 19, TailwindCSS
Desktop      PySide6, Electron 28, Flutter/Dart
Security     AES-256-GCM, PBKDF2, MFA, Audit Chain
Cloud GPU    Kaggle T4, Modal T4, Colab T4, Lightning T4
```

---

## What I Learned

**1. Build the boring parts first.**
Everyone wants to build the AI. The hard part is the 17-stage pipeline, the security primitives, the cloud GPU scheduler. Build those first.

**2. Free cloud GPUs are enough.**
Kaggle + Modal + Colab + Lightning = 4 free T4 tiers. You don't need an $800/month A100 to train a 2.2B model.

**3. Local-first is a feature, not a limitation.**
When the AI runs on your machine, you can break things, modify things, and experiment without worrying about API costs or rate limits.

**4. Composition beats monoliths.**
Each CODA component works standalone. This means I can ship parts of the system without waiting for the whole thing to be ready.

---

## What's Next

- **Train KARNA** (the 2.2B assistant) to completion on free cloud GPUs
- **CODA Forge** improvements: better face reconstruction, multi-person support
- **VIJAY** voice improvements: faster wake word detection, better compound commands
- **Community**: open to contributors, looking for people who want to build local-first AI

---

## Try It

```
git clone https://github.com/Sachitt-AV-08/COSMIC.git
cd COSMIC
pip install -r requirements.txt
python -m core_engine.pipeline.orchestrator --video input.mp4 --height 175
```

Or just explore the repos:
- [BHAASM Transformer](https://github.com/Sachitt-AV-08/bhaasm-transformer) -- the neural brain
- [CODA Forge 3D](https://github.com/Sachitt-AV-08/coda-forge-3d) -- 3D reconstruction
- [Rotation-Scan 3D](https://github.com/Sachitt-AV-08/rotation-scan-3d) -- no-GPU 3D scanning
- [Deception Engine](https://github.com/Sachitt-AV-08/deception-engine) -- security through deception
- [COSMIC](https://github.com/Sachitt-AV-08/COSMIC) -- the umbrella

---

**296,000 lines. 25+ components. 5 languages. 1 developer. All local.**

That's CODA.

---

*Built by A.V. Sachitt. Find me on [GitHub](https://github.com/Sachitt-AV-08) and [LinkedIn](https://www.linkedin.com/in/sachitt-a-v-604224414/).*

This is a submission for [DEV's Summer Bug Smash: Smash Stories](https://dev.to/bugsmash) powered by [Sentry](https://sentry.io/).

Sachitt A V — Tue, 21 Jul 2026 17:53:25 +0000

The Texture That Vanished

I'm 17 and I built a 3D reconstruction pipeline called CODA Forge — it takes a phone rotation video and outputs a photorealistic 3D human model. 18 stages, CPU-only, no cloud. I was proud of it.

Then I exported a GLB file with texture and... it was grey. No texture. Just a flat grey mesh.

I spent 3 hours debugging before I found it. One line.

baseColorTexture=None

That's it. The _export_textured_glb method accepted a texture_path parameter, the caller checked if the file existed, everything looked correct. But inside the method, the texture was hardcoded to None. The parameter was accepted, validated, and then completely ignored.

The fix was two lines:

img = PILImage.open(texture_path)
baseColorTexture=img

But the real lesson was: the code looked correct. The function signature said it took a texture. The caller passed a texture. The validation passed. The export succeeded. It just silently dropped the texture and returned a grey mesh. No error, no warning, no indication anything was wrong.

The Tokenizer That Never Cached

Same week, I was profiling my transformer's generation speed. Something felt slow.

I added timing to the tokenizer calls and found this: the BPE tokenizer was being loaded from disk on every single token generation. For a 256-token output, that's 256 file reads. Each one opens the JSON file, parses it, builds the vocabulary, and initializes the encoder.

The code looked like this:

def _tokenize(text, vocab_size):
    tok_path = Path("data/bpe_tokenizer.json")
    if tok_path.exists():
        tok = load_tokenizer(str(tok_path))  # Loaded EVERY call
        return tok.encode(text)

Two functions (_tokenize and _detokenize) both independently loaded the same tokenizer on every call. No caching. No shared state.

Fixed with functools.lru_cache:

@lru_cache(maxsize=1)
def _get_tokenizer(tokenizer_path="data/bpe_tokenizer.json"):
    tok_path = Path(tokenizer_path)
    if tok_path.exists():
        return load_tokenizer(str(tok_path))
    return None

One load. Cached forever. 256x fewer file reads.

The Call That Did Nothing

Third one was in my rotation-scan pipeline. There was this:

if weight_kg is not None and weight_kg > 0:
    estimate_body_volume(ellipse_params, lengths_cm)           # Result thrown away
    estimate_body_volume(ellipse_params, lengths_cm, weight_kg=weight_kg)

The first call computed volume without weight calibration. The result was never stored, never used, never returned. Then the second call recomputed everything with weight calibration. The first call was pure waste.

I stared at this for 10 minutes trying to understand if there was some side effect I was missing. There wasn't. It was just a leftover from an earlier refactor where the first call used to do something.

What I Learned

Silent bugs are the worst bugs. The texture export "worked" — it produced a file. It just produced the wrong file. No exception, no traceback, no error message.
Profile before you optimize. The tokenizer thing looked fine in code review. Only profiling revealed the 256x redundancy.
Dead code lies. The redundant estimate_body_volume call looked intentional. It wasn't. It was just... there.

All three fixes are live, CI-passing across Python 3.10, 3.11, and 3.12.

GitHub: https://github.com/Sachitt-AV-08/coda-forge-3d
GitHub: https://github.com/Sachitt-AV-08/bhaasm-transformer
GitHub: https://github.com/Sachitt-AV-08/rotation-scan-3d

This is a submission for [DEV's Summer Bug Smash: Clear the Lineup](https://dev.to/bugsmash) powered by [Sentry](https://sentry.io/).

Sachitt A V — Tue, 21 Jul 2026 17:40:36 +0000

This is a submission for DEV's Summer Bug Smash: Clear the Lineup powered by Sentry.

Project Overview

CODA OS is a fully local AI ecosystem — 228K+ lines of code, custom 2.2B transformer, 3D body reconstruction from phone videos, voice assistant, video calling, messaging. Zero cloud dependency.

The specific repos I fixed:

rotation-scan-3d — CPU-only 3D body reconstruction from phone rotation videos
coda-forge-3d — 18-stage photorealistic 3D reconstruction pipeline
bhaasm-transformer — Custom decoder-only transformer with MoE, GQA, RoPE

Bug Fix or Performance Improvement

Three issues across three repos:

1. Texture bug in GLB export (coda-forge-3d)

The _export_textured_glb method accepted a texture_path parameter but never used it. The texture was hardcoded to None, so every textured GLB export lost its texture. This meant users calling export_all(mesh_path, texture_path="texture.png") would get a GLB without any texture applied.

2. Tokenizer loaded 256 times per generation (bhaasm-transformer)

The _tokenize and _detokenize functions in sampler.py each independently loaded the BPE tokenizer from disk on every single call. During generation with max_new_tokens=256, this meant 256+ file reads and tokenizer initializations. The tokenizer was never cached.

3. Redundant computation (rotation-scan-3d)

In pipeline_adapter.py, estimate_body_volume() was called twice in succession — once without weight_kg (result discarded) and once with weight_kg. The first call was wasted computation that did nothing.

Code

Fix 1: Texture bug — coda-forge-3d/src/codaforge/export/export_manager.py

# Before (broken):
def _export_textured_glb(self, mesh, texture_path, path):
    material = trimesh.visual.material.PBRMaterial(
        baseColorTexture=None,  # <-- BUG: texture ignored
        baseColorFactor=[1.0, 1.0, 1.0, 1.0],
    )
    if mesh.visual.kind == "texture":
        mesh.visual.material = material
    mesh.export(path, file_type="glb")

# After (fixed):
def _export_textured_glb(self, mesh, texture_path, path):
    import PIL.Image as PILImage
    img = PILImage.open(texture_path)
    material = trimesh.visual.material.PBRMaterial(
        baseColorTexture=img,  # <-- Now actually uses the texture
        baseColorFactor=[1.0, 1.0, 1.0, 1.0],
    )
    mesh.visual.material = material
    mesh.export(path, file_type="glb")

Fix 2: Tokenizer caching — bhaasm-transformer/src/bhaasm/inference/sampler.py

# Before (slow):
def _tokenize(text, vocab_size):
    try:
        tok_path = Path("data/bpe_tokenizer.json")
        if tok_path.exists():
            tok = load_tokenizer(str(tok_path))  # Loaded every call
            return tok.encode(text)
    except Exception:
        pass
    return [min(ord(c), vocab_size - 1) for c in text] + [0]

# After (fast):
from functools import lru_cache

@lru_cache(maxsize=1)
def _get_tokenizer(tokenizer_path="data/bpe_tokenizer.json"):
    tok_path = Path(tokenizer_path)
    if tok_path.exists():
        return load_tokenizer(str(tok_path))
    return None

def _tokenize(text, vocab_size):
    tok = _get_tokenizer()
    if tok is not None:
        return tok.encode(text)
    return [min(ord(c), vocab_size - 1) for c in text] + [0]

Fix 3: Redundant call — rotation-scan-3d/src/rotationscan/pipeline_adapter.py

# Before (wasted):
if weight_kg is not None and weight_kg > 0:
    estimate_body_volume(ellipse_params, lengths_cm)           # Result discarded
    estimate_body_volume(ellipse_params, lengths_cm, weight_kg=weight_kg)

# After (clean):
if weight_kg is not None and weight_kg > 0:
    estimate_body_volume(ellipse_params, lengths_cm, weight_kg=weight_kg)

My Improvements

Texture fix: The bug was subtle — the method signature accepted texture_path and the caller checked if texture_path and os.path.isfile(texture_path) before calling it, so it looked like it should work. But inside the method, baseColorTexture=None meant the texture was silently dropped. The fix loads the image with PIL and passes it to PBRMaterial. Also added error handling around trimesh.load in the parent export_all method.

Tokenizer performance: The old code loaded the tokenizer from disk on every _tokenize and _detokenize call. During a 256-token generation, that's 512+ file reads. Using functools.lru_cache(maxsize=1) caches the tokenizer object after the first load. Same tokenizer, zero re-reads. The _detokenize function was also updated to use the cached tokenizer instead of independently loading its own copy.

Redundant computation: The first estimate_body_volume call computed uncalibrated volume but discarded the result. The second call recomputed with weight calibration. Removing the first call eliminates unnecessary work without changing behavior — the calibrated result is identical.

All three fixes are committed and CI-passing across Python 3.10, 3.11, and 3.12.

Best Use of Sentry

Not submitting to this category.

I built a fully local AI ecosystem — 3D reconstruction, voice assistant, video calling, messaging — all on your hardware, $0 cloud cost

Sachitt A V — Tue, 21 Jul 2026 17:25:58 +0000

Body:

Hey r/selfhosted,

I've been building what I call CODA OS — not really an operating system, more like a complete AI-native ecosystem that runs entirely on local hardware. No API keys, no subscriptions, no data leaving your machine.

What's in it:

CODA Forge — 3D human reconstruction from phone rotation videos. 18-stage pipeline, CPU-only geometric reconstruction. Outputs photorealistic 3D models (OBJ/GLB/STL) with face reconstruction and texture baking.

BHAASM Transformer — Custom 2.2B parameter language model with Mixture of Experts, Grouped Query Attention, and Rotary Position Embeddings. Trained on Kaggle T4x2 + P100. I progressively replaced every weight from TinyLlama-1.1B until nothing original remained.

VIJAY Voice Assistant — Desktop voice assistant with wake word detection ("Hey VIJAY"), Whisper-based STT, edge-tts TTS, 30+ capabilities (web search, system control, file operations, media playback, etc.). Runs locally, no cloud needed.

CODA Call — WebRTC video calling with STUN/TURN relay, Flutter + Web clients, cross-network NAT traversal.

CODA Connect — Real-time messaging with WebSocket push, token-based auth, full REST API.

SPECTRA — Gesture control via MediaPipe hand tracking for spatial interaction.

Security: Deception honeypot framework, AES-256-GCM encryption, Argon2 password hashing, tamper-evident audit chains.

Why I built it: I'm 17 and couldn't afford cloud AI APIs. So I built everything to run on my RTX 5070 + Intel NPU laptop. The 3D reconstruction part actually works better on CPU than GPU because it's pure geometry.

What's next: Training the transformer to 1B parameters, writing an IEEE paper on the rotation-scan algorithm, and launching the 3D reconstruction as a B2B API.

GitHub: https://github.com/Sachitt-AV-08

Website: https://codaos.qzz.io

Would love feedback from the self-hosted community. What would you use? What's missing?