DEV Community: Sachitt A V

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?