Vikram Aditya retweeted
Here's my first of many (shit)posts on X:
"I'm thrilled to announce that I have spent nearly all of money, leaving my bank account in a crippling state.
This amazing experience afforded me great skills such as excessive expenditure, inflated lifestyles and a lot more."
Vikram Aditya retweeted
minecraft, but the animals have opinions.
I built a mod that lets me actually talk to them. Different voices, different personalities, and they react to what’s happening around them.
Voices by @FishAudio Drama 3.
this is so true, if your motivation to travel is to escape the crisis of your life, its only going to make it worse
escaping the reality doesn’t make the reality go away, better just face and fix your pathetic lives
however i still feel travelling and meeting new people unlocks/stimulates different parts of your brain which in turn gives you a better framework/perspective to shape your life so its all about your intent
building Weave : a p2p overlay network in rust.
packets, routing, peer discovery, handling nodes going offline. the whole thing.
starting from the basics and seeing how far i can take it.
Vikram Aditya retweeted
FOSS FORGE 2.0 by UFC (USAR FOSS Club) is live! 🚀
₹5,00,000+ prize pool
Real-world challenges, not hackathon PS
CTFs, security, AI/ML, automation, web & more
Quiz + leaderboard shape your challenges
Register: unstop.com/o/2qr951x
Details: fossclub.tech/foss-forge-2
proposal for the Oppiabot Consolidation Project got accepted :)
starting my internship at Oppia Foundation, where I'll be working on a unified TypeScript Core Engine + Plugin Framework for Oppiabot.
gonna be working on the architecture, plugin system, GitHub integrations, and migrating the existing workflows over to it.
should be a pretty interesting few months :)
was inactive due to some days due to fuckass college but now
--> finished the ownership and fencing part, so an old worker can't keep renewing or acknowledging a task after its lease has been replaced
--> made recovery race-safe too : recovery now checks the lease again before requeueing, instead of trusting the result of an earlier expiry scan
--> connected lease loss to the actual handler, so a worker losing ownership can cancel the task it's currently running
--> after getting the failure path into a decent state, I started looking at performance and found another unnecessary Redis trip in the normal execution path
--> changed the claim script to return the task body along with the lease, then ran the benchmark properly — ~8.26k tasks/sec vs ~7.86k before
--> also started doing proper head-to-head runs against BullMQ. we're currently pretty close on a quiet machine, which gives me a much better baseline for figuring out where the next gains actually are
--> turns out the interesting part isn't really Go vs Node it's actually how much Redis work we're doing per task
next: batching that work and seeing how far the numbers actually move then add dead letter queue and metrics etc and then maybe some more optimizations till we are better
--> Redis now handles the queue state, with tasks moving atomically from READY → IN-FLIGHT through Lua, and every claim gets its own lease
--> Built the failure path where a dead worker leaves an expired lease, the recovery loop detects it, requeues the task, and another worker can pick it up
--> Added lease-aware ACKs, so only the worker holding the current lease can acknowledge the task
--> Added heartbeats so long-running tasks can keep extending their lease instead of getting falsely requeued
--> Tested the failure path end-to-end: fail --> lease expiry --> requeue --> retry --> success → ACK
next: finish ownership/fencing + make the recovery race-safe, then multi-node failure testing
FAFOing my way through distributed systems by actually building the shit I keep reading about lol
Vikram Aditya retweeted
You can skip all the parties, all the conferences, all the press, all the tweets. Build a great product and get users and win.
Vikram Aditya retweeted
500+ registrations already, in less than 48 Hours
It’s not just an event but a community now
Hosting an event is not just about numbers but seeing the growing interest and growth is amazing
And we’re just getting started💜
24th Oct, New Delhi
Register: luma.com/nkuun44n
Vikram Aditya retweeted
We brought @FishAudio to India 🇮🇳
And we're starting with Delhi.
Fish Audio's first-ever India community event. 💜
New model, Free credits
3-hour Build-A-Thon.
Food + networking.
Register: luma.com/nkuun44n
Come build something with us.
24th Oct. New Delhi.
Hiring a Growth & Distribution Associate for a Delhi NCR loan advisory business
📍 Karol Bagh, Delhi - full-time, onsite
💰 ₹20–25K fixed + uncapped incentives
Focus: finding and reaching borrowers/businesses with ₹1 Cr+ loan requirements
Reposts, shares and tags appreciated
Vikram Aditya retweeted
Everyone says learn inference, learn CUDA,learn ML
But almost nobody tells you exactly what to learn, how to learn it, or how to know whether you’ve actually learned it.
Introducing Trentorch.com a free, open-source platform to learn and practice Machine Learning, CUDA, and inference through hands-on coding.
Instead of just watching lectures or reading theory, you’ll:
• Learn the theory behind each concept
• Follow step-by-step implementation examples
• Solve coding challenges based on what you learned
• Implement algorithms from scratch, from foundational ML to Inference and CUDA kernel
• Practice problems in a Codeforces-style environment
• Get new Problem of the Day challenges with ratings
The goal isn't just to teach you how to write the code.
It’s to help you understand what your code is actually doing underneath.
We’re building Trentorch because advanced education shouldn’t be locked behind expensive subscriptions.
Money shouldn’t be the barrier to learning ML, inference, or CUDA.
A free alternative to platforms that charge students heavily every month.
signup and start solving problems now
Trentorch.com
good morning, here for the morning read today
read In Search of an Understandable Consensus Algorithm aka the Raft paper today.
the thing i liked most wasn't even Raft itself. it was the way they approached system design.
Paxos wasn't wrong. the problem was that it was difficult to understand and didn't map cleanly to practical implementations. so the authors made understandability an actual design goal so they can understand what's actually going on.
their approach was basically:
"break the problem + reduce the state space"
instead of trying to reason about everything at once raft separates leader election log replication, safety and membership changes.
they also deliberately restrict how inconsistent the system is allowed to become.
the core idea is quite clean:
elect one leader --> leader owns the log --> replicate entries to followers --> commit once replicated to a majority.
then here's the interesting engineering problems which showed up.
what happens when the leader dies halfway through replication?
--> what if a follower has missing entries or extra uncommitted entries?
--> what if an old entry exists on a majority but isn't actually committed?
--> what stops a new leader from being elected without committed history?
Raft solves these with things like randomized election timeouts, nextIndex, log consistency checks, and most importantly the restriction that a candidate's log has to be sufficiently up-to-date before it can win an election.
the commitment rule is also quite subtle ngl
a leader can commit an entry from its current term by replicating it to a majority, but merely having an entry from an older term on a majority doesn't necessarily make it committed. the paper gives a pretty good failure sequence showing why.
then they go beyond the basic algorithm: cluster membership changes through joint consensus, snapshots for log compaction, linearizable client interaction, duplicate-request handling, and safe read-only operations.
and what makes the paper especially good is that they don't stop at proposing the algorithm.
they implemented it, formally specified parts of its safety, measured its performance, and even ran a study comparing how well students understood Raft vs Paxos.
so a bigger lesson for me was quite :
understandability isn't just a nice property of a system design it's very the important in its own way.
because the algorithm described in a paper is eventually going to become thousands of lines of code with failure handling, persistence, networking, recovery, optimizations and corner cases that needs to be understand,
if you don't understand why the invariants hold, it's pretty easy to accidentally destroy them while building the actual system.
pretty damn good paper after my zippydb blog which i will release today i will write about it as well.
Vikram Aditya retweeted
Our system paper is accepted at @emnlpmeeting @SHROOM_ST 2026, the shared task on hallucination detection in VLMs, hosted at the UncertaiNLP workshop
The task: given an image, a prompt and a VLM answer in EN/FR/IT/ZH, mark every hallucinated character span, give it a probability, and label it (invention, mischaracterization, OCR, miscounting, other).
Thread 🧵 1/4































