I had the same issues. Moved to Bglr 4 yrs ago first time, The Culture and the Work life balance is so much better, in fact its worst in Chennai. No wonder No one wants to choose to wrk in Chennai.
Mgr thinks can get full control of his subordinates. NEVER going back to chennai.
Nenga ena kadichaalum paravala, Bangalore Corporate Ecosystem >>>>>>> Chennai.
One of the unethical and unprofessional ecosystem ever saw, Atleast during a rainy days it can be a WFH for who're all commuting bit long.
Everything was mid / L since I started in Chennai.
Europe came to lecture India on climate responsibility...
The unexpected twist? Piyush Goyal came prepared with facts, figures & reality check to slap them hard 😂🔥
- you are
- a normal dev with zero clue how LLMs actually work
- want to know how it all runs together
- suddenly: you see the layers, the tradeoffs, the forbidden math
- first: what even is “running a model”?
- model = weights (giant files, 2–140GB) + model architecture (transformer) + tokenizer + config
- weights: the model’s “knowledge”, billions of learned numbers (parameters)
- inference = “guess the next token, over and over”
- you give it a prompt, it spits out text, one chunk (token) at a time
- no training, just pattern-matching what it already knows
- tokens ≠ words
- tokenizer: chops up your text (“internationalization” = 6 tokens, “lol” = 1 token, “🐍” = who knows)
- tokens = the actual input the model sees (as integers, token IDs)
- common types: BPE, SentencePiece
- context window: how many tokens fit in memory (2K, 8K, 32K+)
- bigger window = more GPU RAM burned per chat
- every generation step:
- model reads your sequence (tokens so far)
- does math on weights (layers deep)
- predicts the next token (a probability over all tokens)
- picks one (greedy or sampled), appends, repeats
- one token at a time, every time
- under the hood:
- transformer architecture = the recipe for intelligence
- stack of layers, each with attention + MLPs + position encodings
- self-attention: “which past tokens should I care about right now?”
- RoPE/rotary: “what’s the order of these tokens?”
- each layer = more understanding, more context
- stack N layers deep (7B = ~32 layers, 70B = even more)
- model size: 7B, 13B, 70B, etc. (“B” = billion params)
- bigger model = smarter, hungrier (for VRAM and compute)
- VRAM: the hard limit
- must fit: model weights + KV cache (input of active conv)
- 7B, FP16 = ~14GB; 4-bit quantized = ~3.5GB
- KV cache = 0.5MB/token is a good ballpark (4K tokens = ~2GB for 7B)
- quantization: lower precision, smaller/faster, a bit dumber
- INT4/NF4 (4-bit) is the sweet spot for most consumer GPUs
- decoding: how you pick the next token
- greedy = always pick #1 (robot mode)
- temperature/top-k/top-p = sample from top tokens, control randomness
- typical sampling, repetition penalty = tune output style, avoid loops
- what happens when you “load a model”?
- download weights, tokenizer, config
- load into VRAM/CPU
- warmup (first pass is slowest)
- then: token-by-token inference
- serving options:
- vLLM for throughput/parallel serving
- llama.cpp server (portable, OpenAI API compatible)
- ExLlama v2/v3
- FastAPI/Flask for local endpoints
- tradeoffs everywhere:
- bigger model = stronger, eats more memory
- more context = longer chats, but more VRAM & latency
- quantization = faster/cheaper, maybe dumber
- why local? why bother?
- full control: tweak samplers, chat templates, quant levels, context, prompts
- privacy: your chats, your machine, zero API calls
- common pitfalls:
- OOM? Out of memory, quantize or shrink context
- gibberish? Wrong template or used a base model with chat prompt
- slow? Offloading to CPU, missing FlashAttention or drivers
- what’s a “chat template”?
- chat/instruct models need special system/user/assistant markup
- wrong template = hallucinations or silence
- running local checklist:
- pick model (chat-tuned, fits VRAM)
- pick precision (4-bit = RAM win, FP16 = max IQ)
- install runtime (vLLM, llama.cpp, PyTorch)
- run, check tokens/sec and memory fit
- use correct chat template
- tune decoding (temp/top_p/etc)
- glossary: (keep it simple)
- token: subword chunk (integer)
- context window: max visible tokens
- KV cache: the session memory
- finally:
- local LLMs = memory math + format hygiene + knob mastery
- fit weights and KV cache
- use the right prompt template
- pick your sampler
- master these, and you can run (and reason about) any modern LLM locally
- go build, tweak, and run the future yourself
You can just ask Perplexity Comet to generate a video for you using Veo 3 inside Gemini 🙂
You can either give a detailed prompt with steps or just keep it simple like this, both work:
Comet Prompt:
You have access to the Gemini interface, use it to generate a video and wait for rendering to complete.
Prompt: <Your prompt goes here>
It figures out the rest. Where to paste the prompt, whether to click the video option, everything. Pretty smart.