KJ

The Bunny in 100 Holes

2026-03-06T00:00:00Z

⊕
jump bunny jump

Problem goes like this:

There are 100 holes in a line and there is bunny🐇 hiding in one of them.
You can only look in one hole at a time, every time you look it jumps to adjacent hole.

What’s your strategy?

Take a breath. Think before reading on.

I found this through Uli’s blog. Uli tried the obvious “smart” strategy (always check the most probable hole) and found it barely beat random guessing. That bothered me. So I went down a rabbit hole. Yes, I know.

What I thought would be a quick afternoon turned into bandit algorithms and eventually a lesson I should have learned much earlier: make sure you’re measuring the right thing before you start optimizing.

§ Randomly picking hole:

The naive strategy: just pick a random hole each time, no thinking involved. In code:

import random

# No of holes:
N = 100

def jump(hole):
    if hole == 0:
        return hole + 1
    elif hole == N - 1:
        return hole -1
    else:
        return hole + random.choice([-1, 1])

def play():
    # pickup random hole
    hole = random.randint(0, N - 1)
    t = 0

    while True:
        t += 1
        guess = random.randint(0, N - 1)
        if hole == guess:
            print(f'Found the bunny in hole {guess} after {t} tries!')
            break
        else:
            print(f'[{t}] Guessed {guess} (true is {hole})')
            # wrong hole, bunny jumps:
            hole = jump(hole)
    return t

if __name__ == "__main__":
    play()

When you run it you will see the number of tries it took to find the bunny:

$ uv run bunn.py
[1] Guessed 29 (true is 55)
[2] Guessed 75 (true is 56)
[3] Guessed 68 (true is 55)
...
[175] Guessed 28 (true is 55)
[176] Guessed 74 (true is 54)
Found the bunny in hole 55 after 177 tries!

One simple way to find out how good my strategy is to find out how well it does on average:

r = [play() for _ in range(10000)]

import statistics as stats
mean, median, stdev = stats.mean(r), stats.median(r), stats.stdev(r)
print(f'mean: {mean} median: {median} stddev {stdev}')

I get this:

mean: 99.3195 median: 70.0 stddev 97.85726556670393

About 100 guesses on average. Half the time I finish in 70 or fewer. But sometimes it drags past 500. Very unpredictable.

§ Getting smarter: track where the bunny probably is

Random guessing throws away all information. Every time I check a hole and miss, I know the bunny is not there. And since the bunny can only move one step, I also know something about where it went. Let’s use that.

The idea: maintain a probability distribution P over all 100 holes. Start uniform (bunny equally likely anywhere). After each miss, update two things. First, zero out the hole I just checked and renormalize. Second, spread the distribution one step to account for the bunny jumping.

def guess(P, j):
    # bunny is not in hole j, remove it and renormalize
    s = sum(P) - P[j]
    return [0 if i == j else P[i] / s for i in range(N)]

def jumps(P):
    # bunny took one random step, diffuse the distribution
    Pn = P.copy()
    Pn[0] = P[1] * 0.5
    Pn[N-1] = P[N-2] * 0.5
    for j in range(1, N-1):
        Pn[j] = 0.5 * P[j-1] + 0.5 * P[j+1]
    return Pn

Then always check argmax(P), the most probable hole. After every miss, zero out that hole, renormalize, and diffuse to neighbors to account for the jump. Makes sense in theory. Let’s see.

mean: 94.5  median: 50.5  stddev: 118.4

Barely beats random on mean. Worse stddev. What went wrong?

The belief state P[] is actually correct. The problem is what I do with it. Always picking argmax(P) causes a ping-pong trap. I check hole 50, miss, probability peaks split to 49 and 51. I check 51, miss, peak shifts to 50 and 52. I check 50 again. I keep bouncing in the same neighborhood while the bunny has long since wandered off to hole 30. I am laser-focused on a region the bunny already escaped.

The information is good. The decision rule on top of it is not.

§ Getting excited: bandit algorithms

This felt like a classic exploration vs exploitation problem. I have a good estimate of where the bunny is (exploit that), but I also need to check holes I have not visited in a while in case the bunny drifted there (explore those). There is a whole field built around this exact tradeoff: multi-armed bandits.

The standard algorithm is UCB (Upper Confidence Bound). Add a bonus to each option based on how long it has been since I tried it. Holes I have not checked recently get boosted, which forces me to spread attention over time.

def ucb_choice(P, visits, t, c=1.5):
    scores = [P[i] + c * np.sqrt(np.log(t) / (visits[i] + 1))
              for i in range(N)]
    return argmax(scores)

Result:

mean: 79.9  median: 56.0  stddev: 76.5

Mean dropped from 94 to 79. I got excited. I started tuning c, trying linear staleness instead of the log-sqrt formula, trying hybrid approaches. Each run felt like progress because the mean kept inching down. Linear staleness (P[i] + c*(t - last_visit[i])), gradient-aware scoring, anti-ping-pong penalties. Eventually got the mean down to around 75.

I thought I was winning.

§ The column I was not looking at

Here is the full comparison I should have been looking at from the very beginning.

Strategy         Mean    Median   StdDev   Max
------------------------------------------------
random           97.3      65.0     97.6    727
argmax           94.5      50.5    118.4   1021
ucb_c1.5         79.9      56.0     76.5    574
sweep            98.5     100.0     58.1    198

Look at the sweep row. Just scanning left to right, then right to left, repeating forever. The mean looks bad at 98.5, worse than UCB’s 79.9. I had been dismissing it the whole time based on that one number. But look at the last column. Max of 198. Always. No exceptions across 10,000 runs.

UCB occasionally takes 574 steps. My best staleness strategy hits 620 in the worst case. The sweep never exceeds 198.

The reason is a simple physical argument. The bunny moves one step per turn. The sweep also advances one position per turn. The bunny cannot outrun a sweep. On a 100-hole line, one full back-and-forth covers every hole in exactly 2x(100-1) = 198 steps, and that bound is guaranteed.

def sweep_position(t):
    period = 2 * (N - 1)   # 198
    pos = t % period
    if pos < N:
        return pos           # forward: 0 to 99
    else:
        return period - pos  # backward: 99 to 0

The stddev tells the same story. Sweep gets 58. UCB gets 76. All my staleness variants get 75 or higher. The boring sweep is the most consistent strategy by a wide margin.

I spent days pushing the mean from 94 down to 76, completely ignoring the max and stddev columns. The sweep had better variance and a hard upper bound the whole time. I just was not looking.

§ Why mean was the wrong thing to optimize

UCB was designed for stationary slot machines. Each arm has a fixed unknown payout and you want to find the best one over time. Here the “arms” are not stationary. The bunny moves. UCB has no model of that movement at all. Its exploration bonus happened to force rotation, which happened to reduce the mean, but this was accidental. UCB has no worst-case guarantee because it was never built to think about a moving target.

The sweep encodes exactly one fact: the bunny is a 1D random walker and cannot teleport. That physical constraint is where the hard guarantee comes from. No bandit algorithm can exploit that constraint because bandit algorithms do not model the target at all.

Depending on what I actually care about, the right answer is very different:

Goal	Best strategy
Minimize average steps	UCB or lin_staleness (~76 mean)
Minimize worst case	Sweep (198 steps, guaranteed)
Minimize variance	Sweep (StdDev 58 vs 76+)
Search and rescue, anything high stakes	Sweep, not even close

§ One more twist: what if the bunny is smart?

Everything above assumed the bunny moves randomly. What if it moves against me, always jumping away from the hole I just checked?

Holes: 1, 2, 3, 4, 5. I just checked hole 3.

Random bunny in hole 2: goes to 1 or 3 with equal probability
Adversarial bunny in hole 2: always goes to 1, never toward the checked hole

Now the sweep fails completely. A bunny that knows my pattern can stay one step ahead of a predictable sweep forever. The problem becomes pursuit-evasion, and I need randomness in my own strategy to have any guarantee. Everything changes.

That is a rabbit hole for another day.

*Full source code here. Problem originally from Uli’s blog.

You want to do everything?

2026-03-05T00:00:00Z

You wake up and see someone playing guitar. Now you want to play guitar.
⊕
jump bunny jump
You see someone with great physique. Now you want that body. Hardware,Software, AI, Design, Hacking, Painting… the list never ends and every new thing feels urgent.

Her’s the pattern: You spend hours researching the hobby/skill. Watching videos, reading threads, gathering information as much as you can. It feels productive. It isn’t. The research is simulation of commitment, your brain gets the illusion of progress without the discomfort of actual practice.

And even if you start, you quit after one or two attempts. Not because you didn’t want it, but because something new arrived before the old thing got hard enough to get good.

People say the silver bullet is just being high agency at everything. well it isn’t. People treat agency as the solution to everything, but agency without commitment is just faster context-switching. You become extremely efficient at starting things. That’s not a virtue, that’s a more energetic version of the same problem.

What actually works is staying with something long enough to be genuinely bored by it. That dead zone between beginner excitement and real skill, where nothing feels fun and results aren’t comming yet, is where most people quit. It’s also where everything important happens. Sitting in that discomfort is how you find out what you actually like versus what just looked good from the outside. People call this type 2 fun. The enjoyment that only arrives after the struggle.

Palmer Luckey said it better than I can:

“At some point, in business and in life and in romance, you have to commit to a path,” said the 31-year-old Luckey. “A lot of my peers in the tech industry do not share this philosophy … They’re always pursuing everything with optionality. ’Oh, I need to be able to raise money from anybody. I need to be able to sell my business in any way. I need to have liquidity in any way. I need to make sure that I’m not closing myself off to future romantic partners. I need to make sure I’ve got my options open. I need to make sure that I’m not going to buy a house and settle down in one place and lock myself down. Oh, having children. I don’t know. Maybe I’m not ready to commit to that path.’”

“In keeping their options open, they ensure that they’re going to jump from option to option. If you don’t commit to a path, you’re going to fail at it … You have to commit to it to make it work, and I think marriage is the same way. You just have to commit to it. You have to say, ’This is the path I’m on. For better or for worse, I’m going to double down on it.’”

The trap isn’t curiosity. Curiosity is good. The trap is using optionality as a permanent address. Staying open to everything because closing off feels like loss. It doesn’t feel like a trap. It feels like freedom. But you’re not free, you’re just permanently in preview mode. Never in the actual movie.

Commitment isn’t about certainty. You rarely know before you commit. Commitment is the mechanism by which you find out. You don’t commit because you’re sure, you commit to become sure.

Take whatever time you need to find the thing. But at some point, pick it and stay.

What I learned building a vector database on object storage

2025-12-09T00:00:00Z

When I came across Turbopuffer, a vector database built entirely on object storage, I got curious. Really curious. The architecture seemed almost too simple. Write-ahead logs on S3? Centroid-based indexes? Stateless query nodes? It felt like someone had taken all the “rules” of database design and just… ignored them.

I wanted to understand the tradeoffs myself. Not by reading more blog posts, but by actually building something. Also I broke up with my girlfriend, so I have nothing else to do.

We’ll build a naive vector database on S3, inspired by Turbopuffer’s architecture, using first principles and napkin math. We’ll hit walls, make mistakes, and hopefully learn what design decisions we need to make.

The more interesting thing about this is, S3 is meant to be object storage, it’s not that designed for database operations. We need to think about updates, deletes, managing indexes - how we store them, update them, and minimize roundtrips because every extra roundtrip is 200ms latency which your users will not likeTraditional databases optimize for low latency, S3 optimizes for throughput and cost.. So it’s not that easy to just use S3 and turn it up to infinite scale.

I’m not a database expert. I’m not the hardcore database guy who tweets about LSM trees and drops random MySQL facts at parties. I’m just someone who likes tinkering with things to understand how they work.

This is a learning exercise. I’m building my own version of turbopuffer to really understand the trade offs, the gotchas, and why certain decisions were made. If you’re looking for production-ready code or groundbreaking research, this isn’t it. But if you want to follow along as I figure out how to build a vector database from first principles, you’re in the right place.

§ What are we actually optimizing for?

Why do we even want to build on S3, and why not in a traditional way or use top-of-the-shelf solutions like pgvector or other millions of solutions?

imagine you want to add semantic search to your app. Maybe 100 million vectors. You check pricing for existing vector databases, Pinecone, Qdrant, etc… $20k per month. Just for storage. That’s insane.

Why so expensive? Because traditional vector databases assume you need everything in memory or on expensive replicated SSDs, and that’s where a good scale solution built on top of S3 with smart caching really shows its worth.

That said, let’s set some reasonable goals for what this thing should do:

Doesn’t bankrupt you - Should cost $1500/month for a billion vectors, not $20k
Scales horizontally - Add more namespaces without 10x-ing your costs
Handles writes properly - Real-time inserts/deletes, no rebuilding entire indexes
Is fast enough - Not “fastest possible,” but fast enough (p95 under 500ms for 10k result searches)

Overview of architecture:

// Write path:
  upsert() → write_to_wal() → return_immediately

  // Background (async):
  compactor_job() → read_wal_batch() → build_indexes() → write_indexed_clusters() -> delete_wal_files()

  // Query path (hybrid):
  query() → {
      indexed_data: fast_cluster_lookup(),    // ~10ms
      unindexed_data: scan_recent_wal(),      // ~200ms
      merge_results()
  }

Let’s start with writing and dumping things, simple Write-Ahead Log (WAL) implementation:

On every write request, we store the incoming data in a WAL folder in the user-provided namespace. We use the sequence as WAL file names: namespace/WAL/0000000001.bin.

This is a brute-force approach, but it works.

But now we have another problem: you can easily make a mistake and override the file, and your data is now overwritten, which is really bad for a database.

For this, S3 provides us a good API: you can pass the precondition in the request header to perform conditional writes. So we can simply use if_non_match: * — if the same key already exists, it will give us a 412 status code that the precondition failed.

We also have another latency killer: when a user fires a query asking for results, we need to fetch WAL files. But S3 doesn’t provide a way to fetch all files from a folder — you can only fetch a file, and for that you need to know the exact key name and bucket. S3 doesn’t provide regex-based file fetching either.

The only way is to LIST all files using a paginator, then fetch them in parallel. Each LIST operation is ~200ms per page, and each GET is another ~200ms.

§ The Performance Journey: From 3 Seconds to 30ms

After pushing my crude basic version, I got my first benchmark result. 3 seconds per query. THREE SECONDS.

⊕Initial benchmark showing 3 seconds per query - a shocking result that started the optimization journey

I was devastated. Therefore I started investigating…

§ Step 1: Physics Lesson (3000ms → 1000ms)

I’m in Ahmedabad. Tigris servers are in us-east-1 (Virginia) despite choosing singapore.

Speed of light round-trip: ~250ms
TLS handshake (3 round trips): ~750ms
My naive LIST operation: Another 300ms

I realized I was fighting physics, not code.

I could eliminate the expensive LIST operations. Instead of asking S3 “what WAL files exist?”, I stored the file list in simple metadata.json and cache it, so my first cold query would be expensive but subsequent queries would be fast.

1000ms queries. Better, but still terrible.

⊕After implementing metadata caching - performance improved from 1000ms to 400ms per query

In the above image, we are still using LIST operation, and I think it may have been some routing issue or something, because I was using Tigris blob storage and all other operations were in µs, despite them mentioning they are faster than S3. I wrote to them but didn’t get proper followup.

§ Step 2: Metadata Caching (1000ms → 400ms)

Every query was fetching metadata.json from S3. So why not cache it? I added a window LFU-based cache using moka:

// Window LFU eviction, max 1000 entries
static METADATA_CACHE: Cache<String, Metadata> = Cache::builder()
    .build();

The cache uses a standard HashMap under the hood, the LFU algorithm will evict least-frequently-used entries once the limit is hit. At worst, you’ll have 1000 entries (~1MB total memory for metadata). Memory isn’t a concern here. In reality, if you ever have that many concurrent namespace accesses, your server would crash from in-memory vector buffers long before hitting metadata cache limits. That’s a good problem to have.

I use proactive invalidation on writes to keep the cache fresh, letting the LFU algorithm handle eviction for less-frequently accessed namespaces and to be on safer side added max capacity of 1000.

Result: 400ms queries. Getting warmer.

§ Patch and Delete: The WAL Replay Story

Since everything in our system is append-only (we can’t update S3 objects in-place), how do we handle updates and deletes?

Answer: Write-Ahead Log (WAL) replay with tombstones.

#[derive(Archive, Serialize, Deserialize, Debug, Clone)]
pub enum WalRecord {
    Upsert(Row),
    Delete { id: DocumentId, timestamp: i64 },
    Patch { id: DocumentId, attrs: HashMap<String, AttributeValue>, timestamp: i64 },
}

When you delete a vector, we don’t actually delete anything. We write a tombstone record to the WAL:

// Delete operation
async fn delete(&self, namespace: &str, id: DocumentId) -> Result<()> {
    let tombstone = WalRecord::Delete { id, timestamp: chrono::Utc::now().timestamp() };
    self.write_to_wal(namespace, vec![tombstone]).await
}

Similarly, patches update attributes without rewriting the entire document:

// Patch operation
async fn patch(&self, namespace: &str, id: DocumentId, attrs: HashMap<String, AttributeValue>) -> Result<()> {
    let patch = WalRecord::Patch { id, attrs, timestamp: chrono::Utc::now().timestamp() };
    self.write_to_wal(namespace, vec![patch]).await
}

During query time, we replay the entire WAL to build the current state:

// WAL replay logic
fn replay_wal_with_tombstones(wal_chunks: &[Vec<u8>]) -> Result<(HashMap<DocumentId, Row>, HashMap<String, i64>)> {
    let mut state = HashMap::new();
    let mut deleted_ids = HashMap::new();

    for chunk in wal_chunks {
        let records: Vec<WalRecord> = rkyv::access(&chunk)?;

        for record in records {
            match record {
                WalRecord::Upsert(row) => {
                    state.insert(row.id.clone(), row);
                }
                WalRecord::Delete { id, timestamp } => {
                    deleted_ids.insert(id.to_string(), timestamp);
                    state.remove(&id);
                }
                WalRecord::Patch { id, attrs, timestamp: _ } => {
                    if let Some(row) = state.get_mut(&id) {
                        for (k, v) in attrs {
                            row.attrs.insert(k, v);
                        }
                    }
                }
            }
        }
    }

    Ok((state, deleted_ids))
}

The trade-off: Deletes are fast (just write a tombstone), but WAL replay gets slower as you accumulate more records. That’s why we need compaction…

§ Data Format: Why Rkyv?

Obviously we can’t store things in JSON format, serializing and deserializing JSON is painfully slow for our use case when dealing with millions of vectors!

I wanted to take advantage of zero-copy deserialization (read data directly without loading it entirely into memory first), and that’s why I chose rkyv.

I also considered existing formats like Parquet, but here’s why they don’t work well for real-time vector search:

§ Parquet vs Rkyv: The CPU Battle

Parquet (CPU Heavy)

Parquet is optimized for storage size using heavy compression and encoding (RLE, Snappy/Zstd):

Process: Download bytes → Allocate heap → Decompress → Decode → Construct structs
Result: CPU spends 50% of query time just preparing data before computing similarities

Rkyv (CPU Free)

Rkyv guarantees the data on disk is byte-for-byte identical to its representation in RAM:

Process: Download bytes → Cast pointer → Ready
Result: Data is ready the instant the network request finishes. CPU goes straight to SIMD vector math.

When you’re fetching multi-MB posting lists from S3, this difference is massive. Zero allocations, zero decoding overhead, but at the same time debugging it is also an issue.

§ Write Collisions: The ULID Mistake

Before going for any new optimization, I created a basic benchmark script in Python so I could test things properly instead of just guessing:

uv run vecpuff-bench latency \
 --dataset-size 1000 \
 --vector-dims 1536 \
 --query-count 100 \
 --warmup-queries 2 \
 --batch-size 200

And immediately hit my metadata race condition (remember the collision problem I mentioned earlier):

Under concurrent load, my system was blowing up.

My initial thought was the sequential WAL approach is the main problem — we don’t know what the next sequence is because multiple writers are trying to create files at the same time, and we needed to have sortable IDs for WAL files, otherwise Patch and Delete will not work.

We need IDs which are sortable and unique. I knew about ULID — they are 128-bit IDs, sortable and unique, and 26 characters long, so they are perfect for our use case. I implemented it in my code, it all worked like a charm, just needed to change the logic to store the WAL file names in metadata files.

Here I made a mistake that I realized later after completing the compaction and indexing logic: The problem wasn’t the sequential WAL approach — it was having multiple concurrent writers trying to create files at the same time.

After a few days of debugging and arguing with LLMs about various approaches, I realized the solution:

Don’t fix the collision - eliminate the writers!

§ Smart Batching: Single Writer Architecture

Instead of multiple writers fighting over sequence numbers, funnel all writes through a single batcher:

// Wrong: Multiple writers = collision hell
API Request A → Write wal_00005.bin
API Request B → Write wal_00005.bin  // COLLISION!
API Request C → Write wal_00005.bin  // COLLISION!

// Right: Single writer + batching = no collisions
API Request A ──┐
API Request B ──┤─→ Batcher → Write wal_00005.bin (contains A,B,C)
API Request C ──┘

Scenario 1: Single Write (No Batching)

Time 0ms: Write arrives
Time 285ms: Immediately flush to S3, return success
Result: 285ms latency, no batching benefit

Scenario 2: Multiple Concurrent Writes (Batching)

Time 0ms: Write A arrives → Start batch
Time 50ms: Write B arrives → Add to same batch
Time 100ms: Write C arrives → Add to same batch
Time 285ms: Flush entire batch to S3 → All return success
Result: A=285ms, B=235ms, C=185ms latency

Scenario 3: High Frequency Writes

Time 0ms: Batch 1 (A,B,C) flushes → 285ms latency
Time 200ms: Write D arrives → Start new batch
Time 400ms: Write E arrives → Add to batch
Time 485ms: Flush batch 2 (D,E) → D=285ms, E=85ms

Even after understanding this, I ignored it because I thought this is not a good way - single writer architecture is not good. I liked the idea of batching, but not single writer, because when we have multiple nodes in different regions we need to have different writers. That was my intuition, so I just implemented batching with ULID-based IDs. But after a few days of thinking and arguing with LLMs about various approaches, I realized the solution, and I think this is how Turbopuffer also does this.

Routing is key here - all your requests go to the same node every time, using consistent hashing/hash ring.

So I could have stuck to the sequential WAL IDs approach!

§ Compaction and Indexing:

After benchmarking, I had thousands of WAL records. Replaying them all was taking 200ms+ per query. Time for indexing.

Enter ANN based indexing:
Why everyone loves HNSW:

Hierarchical Navigable Small World graphs
Great for in-memory vector search
Excellent recall and speed

Why HNSW sucks for our use case:
We are going for S3 in the first place to reduce the cost because of our scale. To make HNSW work for our use case, we need to load the entire index in memory — without it, updates and other operations will be too slow.

SPFresh is a good choice for our use case. Watch this video for more details — it uses centroid-based indexing which is good for our use case, and LIRE for updating the index without rebuilding the entire index. I want to go into detail and talk about how it does this, but it would make this blog post a little long, so you can watch the video for more details.

// SPFresh strategy
impl SPFreshIndex {
    pub async fn query_ann_async(
        &mut self,
        query_vector: &[f32],
        top_k: usize
    ) -> Result<Vec<(f32, Row)>> {
        // 1. Find nearest centroids (in-memory, fast)
        let nearest_centroids = self.find_nearest_centroids(query_vector, 3)?;

        // 2. Fetch posting lists for those centroids (parallel S3 GETs)
        let posting_lists = self.load_posting_lists(&nearest_centroids).await?;

        // 3. Compute similarities and return top-k
        self.compute_similarities(query_vector, &posting_lists, top_k)
    }
}

The algorithm:

Cluster vectors into centroids during compaction
Store posting lists for each centroid in S3
Query time: Download centroids (small), find nearest clusters, fetch posting lists (big)

Performance:

Real logs from my benchmarks after implementing SPFresh:

INFO Metadata fetch completed for namespace: vecpuff, WAL files: 0, unindexed_bytes: 0
INFO SPFresh timing - Load: 365.423958ms, Query: 6.045541ms
INFO QUERY PERFORMANCE BREAKDOWN for namespace=vecpuff, docs=10, top_k=10:
INFO TIMINGS: Total=744.565542ms | Metadata=361.259875ms | Filter=42ns | WAL=165.75µs (fetch=49.417µs, replay=115µs) | SPFresh=382.982042ms | Merge=2µs | Sort=21µs
INFO S3 PERFORMANCE: 3 round trips [s3:read:metadata/metadata.json, cache:read:index/spfresh_metadata_01KBYP7BP8WBDPD6SEBKVHP9ZY, cache:read:postings/posting_01KBYP6WGXYW1HGZND1AC3C79A]

SPFresh timing - Load: 365ms, Query: 6ms. Total query: ~800ms cold, ~30ms warm.

The compaction process merges WAL files into indexes:

// Compaction trigger
if metadata.wal_files.len() >= config.reindex_threshold_wal_count
    || metadata.unindexed_bytes >= config.reindex_threshold_bytes {

    tracing::info!("Triggering Compaction for {namespace}");
    tokio::spawn(async move {
        compactor::trigger_compaction(&namespace);
    });
}

This looks really simple but implementing it was not that simple - it took me some time to figure out how to do it properly.

§ The “Zombie WAL” Race Condition

I encountered a race condition where compacted Write-Ahead Log (WAL) files were being “resurrected” in the metadata, effectively undoing the compaction process. This occurred due to a flawed merge strategy during optimistic concurrency control conflicts.

The Scenario

Our system has two concurrent processes updating a shared metadata.json file on S3:

Compactor: Reads metadata, merges old WAL files (e.g., WAL_1, WAL_2, WAL_3) into an index, and updates metadata to remove the old WAL files.
Ingester: Writes a new WAL file (e.g., WAL_4) and updates metadata to add it.

Both use Optimistic Concurrency Control (OCC): read the file, modify it locally, and write it back only if the file hasn’t changed (using ETags). If the write fails, they must retry.

The Bug: State Merging

The issue arose when the Ingester and Compactor conflicted:

Initial State: [WAL_1, WAL_2, WAL_3]
Ingester Start: Reads state, adds WAL_4. Local state: [WAL_1, WAL_2, WAL_3, WAL_4].
Compactor Exec: Compacting 1, 2, 3. Successfully updates S3 to [INDEX_A].
Ingester Conflict: Tries to write its local state but fails because S3 has changed.
Flawed Retry Logic: The Ingester fetched the new remote state ([INDEX_A]) but merged it with its local stale state. It unioned the file lists:
- Remote: [INDEX_A]
- Local: [WAL_1, WAL_2, WAL_3, WAL_4]
- Result: [INDEX_A, WAL_1, WAL_2, WAL_3, WAL_4]

The Ingester inadvertently wrote the old WAL files back into the metadata, creating “zombie WAL files.”

The Fix: Delta Application

To fix this, we changed the retry logic from State Merging to Delta Application.

Instead of treating the local state as a source of truth to be preserved, we treat the Remote State (the one on S3) as the only truth. We then simply re-apply the specific operation (the “delta”) to that fresh state.

Corrected Retry Logic:

Ingester Conflict: Write fails.
Fetch Remote: Get fresh state [INDEX_A].
Apply Delta: The only operation intended was “Add WAL_4”.
- Remote: [INDEX_A]
- Delta: + WAL_4
- Result: [INDEX_A, WAL_4]

This pattern applies to any OCC retry: always re-apply the delta to the fresh remote state, never merge stale local state.

§ Caching: The Secret Sauce

Without caching, every query hits S3. With smart tiered caching, we go from 800ms to 30ms.

Tier 1: In-Memory (Hot)

WAL cache (~500MB), metadata cache (~100KB), and SPFresh index cache with sliding TTLs. Access resets the timer — hot namespaces stay cached. Proactive invalidation on writes ensures consistency.

Tier 2: Local NVMe (Warm)

Write-through file cache for all S3 objects. Try local cache first, fetch from S3 and cache locally on miss.

Tier 3: S3 Standard (Cold)

Object storage, 50-200ms latency
Unlimited capacity, $0.023/GB/month

Note: Metadata uses get_file_with_etag() which bypasses local file cache and goes directly to S3 (for ETag-based optimistic concurrency control).

§ Cache Flow & Performance

Query → Memory → NVMe → S3
        ↓        ↓      ↓
       ~1ms    ~10ms  ~200ms

Real performance:

Memory hit: ~30ms (95% of hot namespaces)
NVMe hit: ~50ms (90% of warm namespaces)
S3 miss: ~800ms (5% cold start)

Storage costs:

Memory: $2/GB (expensive, fast)
NVMe: $0.10/GB (middle tier)
S3: $0.023/GB (cheap, slow)

Cache Invalidation:

WAL cache: Invalidated when files deleted during compaction
Metadata cache: Invalidated on every write + after compaction
SPFresh cache: Invalidated when new index built
Local file cache: Deleted when S3 objects deleted
Sliding TTL keeps hot data cached, proactive invalidation ensures consistency

This architecture works at the speed of in-memory databases with the economics of object storage.

§ Conclusion

The code is not production-ready and definitely not clean. It’s open source under the name VecPuff. I broke up with my girlfriend, so this is mostly how I spent my time - building a database on object storage instead of processing feelings. Will clean it up later.

Building a database on S3 is possible, but it’s not magic. You’re trading latency for cost, complexity for scale. For the right workload, that trade is worth it. For most workloads, it’s probably over-engineering.

Here’s what I actually learned:

Physics beats algorithms. I spent days optimizing queries before realizing I was fighting the speed of light, not code. Geography matters more than cleverness.

S3 request costs will surprise you. Storage is $0.023/GB, but 1M GETs/day is $12/month. My first benchmarks were doing 50+ GETs per query. That math doesn’t work at scale. Batching isn’t optional.

Cache invalidation is harder than it looks. Even with ETags and optimistic concurrency, you’ll hit edge cases. The zombie WAL bug happened because I merged stale local state with fresh remote state. Delta application fixed it, but I should have known better from the start.

Zero-copy actually matters. When you’re fetching 10MB posting lists from S3, JSON deserialization becomes a bottleneck. Rkyv’s zero-copy meant data was ready the instant the network request finished. CPU went straight to SIMD math instead of parsing. The difference was 50ms → 5ms for large fetches.

Race conditions will find you. The zombie WAL bug taught me that distributed systems have a way of exposing your assumptions. State merging seemed logical until it resurrected deleted files. Delta-based operations are the only safe retry pattern.

Embeddings are reversible. They’re lossy compression — you can reconstruct the original data from embeddings. If you’re storing embeddings in S3, encrypt them. Your vectors might leak more than you think.

Building a database to cope with a breakup: surprisingly therapeutic. Would recommend over doom-scrolling.

§ Further Reading

If you want to understand the thinking behind turbopuffer, I highly recommend watching Simon’s talk on Napkin Math. It’s not specifically about turbopuffer, but it shows the first-principles thinking that makes systems like this possible. Before you architect anything, do the math. Understand your constraints. Know what’s physically possible before you start coding.

It’s one of those talks that changes how you approach engineering problems.

More resources:

Turbopuffer Architecture - The inspiration for this
SPFresh Talk
A course on building an LSM-Tree storage engine - Chi is amazing!

My Experience of building bytebeat player in Zig

2025-11-01T00:00:00Z

I graduated last month, and my GSoC project along with my startup work finally wrapped up. To take a proper break and enjoy some deliberate downtime (even a bit of healthy boredom), I decided to spend the weekend building a bytebeat player, something I’d been wanting to do for ages, just for fun.

This was my first time with Zig, and I actually enjoyed writing the code, writing Zig feels like C with friendly defaults.

It is a joy to write, I am not fighting borrow checker or fighting with syntax.

You can call this a passion project, there is no goal or agenda behind building this, I built it because I wanted.

§ Demo

Try the live demo here: https://kmj-007.github.io/zigbeat/

§ Bytebeat

For many people who don’t know what is bytebeat, let me explain:

Bytebeat is music generated from short programs. These programs generate PCM audio as a function of time, see one below which is called 42 melody

t*(42&t>>10)

another way to explain, Bytebeat is a form of algorithmic music that uses bitwise operations, to generate sound, with only one variable t representing time. The expression is evaluated for each sample of the 8bits audio output.

in 2011 viznut discovered this by accident, he blogged about it here

§ Why/How does it work?

Audio on computers is stored as a list of numbers called samples. Each number represents the amplitude (volume level) at a specific moment in time.

Standard audio uses:

16-bit samples at 44.1kHz (CD quality)Higher bit depth = more dynamic range, higher sample rate = better high-frequency response
Each sample is a number between -32768 and 32767
Each sample lasts ~22 microseconds

Bytebeat uses a simpler format:

8-bit samples at 8kHz8kHz was the standard sample rate for early PC sound cards
Each sample is a number between 0 and 255
Each sample lasts 125 microseconds

This simpler format was chosen because it was the default for early PC sound cards on Linux. The lo-fi quality is part of bytebeat’s charm.

for visual learners:

⊕Bytebeat diagram showing the flow from expression to audio output, including evaluation loop, sample generation, and waveform visualization

§ Experience:

First in my mind it was like, bytebeat is very simple, we enter some expression and it plays some sound, it doesn’t sound any rocket science.

It is actually very simple if you make it in javascript, cause it provides eval, which does all the 90% of the work.
but i decided to build it in Zig, so here we go,

I setup my project using old example repo of raylib-Zig examples, but it was outdated, cause i was using 0.15.1,

And i also wanted to support native as well as browser which was reason for picking up raylib in the first place, for which i needed to setup emscripten to compile it to wasm,

I created everything from scratch from editor, to blinking cursor, select, which felt good but made me realize, how much on the abstraction we are standing!

After writing good amount of code in other languages where string was data type in default, I was little surprised that, Zig doesn’t support strings, which lead me to some rabbit holes of understanding how string and struct works in Zig and how they are allocated at byte level,it was refresh for my memory to understand underlying things.

you can’t switch on string in Zig btw!

good blog if you want to understand about struct and memory in Zig, Everything is a []u8

good thing for this project was, lot of LLM tools sucked at writing the Zig, specifically new syntax which is not that much popular on the internet, such as recently Arraylist initialization syntax has been changed, it no longer takes allocator, so i didn’t use any LLM for this project.

§ Arena Allocator:

I ended up implementing Pratt Parser for parsing the expression, after my implementation i was getting different sound of native app and different on browser, and i was scratching my head like what was happening.

After debugging i found that in browser my second and third audio callback had lot of delay, then it clicked me that, on every sample i was creating new AST, allocating memory because of which my program was really slow in evulating the vaules to feed the PCM audio!

then after researching a bit, i was doing wrong memory management, in my case when user types expression and it doesn’t changes, the memory it requires for AST is constant, it is not going to change, so for this use case i learned about Arena Allocator, which is a memory allocator that allocates memory in large chunks and then divides it into smaller chunks for individual allocations.

After your work is done, you just free the memory at once.

good talk if you want to learn more about Arena Allocator and memory management in Zig

§ todo:

While i wanted to make the Zigbeat with the looks of retro 8bitsynth, similar to following image, replacing the piano keys with visualizer

⊕Retro 8-bit synthesizer interface with piano keys and vintage aesthetic design inspiration for ZigBeat

I tried implementing but drawing everything with primitive gradients and draw api from raylib, it was getting nightmare, I joked with my friend about how were they able to do this kind of things in old times they didn’t even have React!, we both laughed,

Then I figured out in games they use something called sprites, which is nothing images, so i picked myself to become designer, here i am trying to draw keys in photoshop:

⊕Work-in-progress screenshot of designing piano key sprites in Photoshop for the ZigBeat interface

and i tried to integrate slowly, here is some screens which looks very bad:

⊕Early prototype screenshot of ZigBeat interface showing initial attempt at integrating custom sprites with Raylib

but it was taking lot of time, only reason me being bad design, but i guess i will finish this on some another weekend.

§ Conclusion:

It was actually really good decision to build with Zig and not javascript, cause i ended up learning lot about parsing and evaluation, from pratt parsing to lexer mods, which i don’t regret!

if you are more curious about bytebeat, here is a Rick Roll in bytebeat

Star on GitHub: https://github.com/KMJ-007/Zigbeat

Happy Hacking!

SAT problems are kind of cool!

2025-10-08T00:00:00Z

While working on fastbrew, I went into the rabbit hole of SAT, short for Boolean satisfiability.

It is quite interesting. For my application I am rewriting brew’s package manager to be faster and more reliable, so it does not update dozens of packages every time I install something and it does not break the ones I already use.

§ A Package Manager Puzzle

Let’s start with a real-life scenario to build intuition.

Imagine you’re setting up your development environment, and you want to install two popular packages:

Node.js (node): You need it for your JavaScript projects.
LLVM: You’re experimenting with compilers, and LLVM is a must.

You run the following command:

fastbrew install node llvm

Node.js depends on an older version of OpenSSL, say openssl@1.1, for its networking features.
LLVM requires a newer version, openssl@3, because it’s built with modern security features.

Both OpenSSL versions expose the same libraries, so installing them together breaks things. Toss wget into the mix. It has no dependencies, and now you are juggling compatibility, versions, and constraints. Is there any combination that keeps the system healthy?

This is the kind of question SAT solvers answer gracefully. You describe the rules: dependencies, conflicts, requirements, and ask, “Is there a solution, and if so, which packages are in it?”

§ What Is SAT?

A SAT problem starts with a Boolean formula that uses AND (∧), OR (∨), and NOT (¬) across a set of variables. The challenge is to assign true or false to each variable so the whole formula evaluates to true. If such an assignment exists, the formula is satisfiable; otherwise it is unsatisfiable.

SAT problems are NP-complete problems: easy to verify, hard to solve. Despite the intimidating label, SAT solvers are surprisingly practical.NP-complete means there's no known fast algorithm, but verifying a solution is quick. This is the class of problems that quantum computers may eventually help with via Grover's algorithm.

⊕3SAT problem

Image by downey.io, source

§ Translating Dependencies into Logic

To encode the earlier fastbrew scenario, assign a Boolean variable to each package:

N: Install node
L: Install llvm
O1: Install openssl@1.1
O3: Install openssl@3
W: Install wget

Then translate dependencies and conflicts into clauses:

N → O1 becomes ¬N ∨ O1.
L → O3 becomes ¬L ∨ O3.
¬(O1 ∧ O3) becomes ¬O1 ∨ ¬O3.

Requesting both node and llvm forces N = true and L = true. The solver then discovers there is no way to satisfy all clauses at once because openssl@1.1 and openssl@3 cannot coexist, so the formula is unsatisfiable. A solver like MiniSAT reports the conflict instantly, sparing you a broken setup.

§ How SAT Solvers Work

Modern solvers behave like methodical puzzle players:

Decide: Pick a variable, guess a value.
Propagate: Infer any values that must follow from that guess.
Conflict-check: If contradictions appear, learn from them and backtrack.

This process repeats with smart heuristics so the solver avoids retracing dead ends. For fastbrew that means validating package plans before touching a single file and explaining why an installation fails.

§ A Tiny Example in Code

Here is a toy SAT model with three packages A, B, and C:

from pysat.solvers import Minisat22

solver = Minisat22()

# Clauses
solver.add_clause([1, 2])    # A ∨ B
solver.add_clause([-1, 3])   # ¬A ∨ C
solver.add_clause([-2, -3])  # ¬B ∨ ¬C

if solver.solve():
    print("Satisfiable:", solver.get_model())
else:
    print("Unsatisfiable")

One satisfying assignment is [1, -2, 3], which means install A and C, skip B. Scale this up to thousands of packages and you have the heart of fastbrew’s dependency solver.

§ Why SAT Helps fastbrew

Conflict awareness: Spot incompatible packages before installation starts.
Minimal churn: Install only the necessary dependencies.
Clear feedback: Explain why an installation fails instead of crashing halfway through.

§ Other Places SAT Shines

Software verification: Tools like CBMC encode program properties as SAT to prove the absence of bugs.
Hardware design: Chip designers rely on SAT to validate circuits under tight performance constraints.
Scheduling: Universities and airlines encode timetables as SAT to avoid double-booking people or resources.
AI planning: Robots and game agents use SAT to plan sequences of actions without violating rules.
Cryptanalysis: SAT solvers stress-test cryptographic schemes by searching for breaking inputs.
Puzzles: Everything from Sudoku to logic riddles can be encoded and solved instantly.

§ SAT Problems Are Everywhere

SAT problems are like universal problem-solvers, turning messy real-world challenges into clean logic puzzles. From preventing package manager disasters in fastbrew to designing faster chips, planning robot routes, or even solving your favorite Sudoku puzzle, SAT is everywhere.

Making Enzyme AutoDiff Stable on Rust (GSoC 2025)

2025-09-05T00:00:00Z

This summer, I worked on making automatic differentiation reliable and stable for the Enzyme project through Google Summer of Code. This post details the challenges I tackled and the solutions I implemented to bridge the gap between Rust’s type system and Enzyme’s requirements.

§ What is Enzyme AutoDiff?

Enzyme is an LLVM-based automatic differentiation (AD) framework that can differentiate programs written in any language that compiles to LLVM IR. Unlike traditional AD tools that require special syntax or library calls, Enzyme works at the LLVM level, making it language-agnostic.

⊕Enzyme LLVM working

§ The Performance Challenge: Why Enzyme Struggles with Rust

The performance challenges with Enzyme on Rust stem from a mismatch between how Rust represents types and what Enzyme needs to work effectively.

§ The Type Information Problem

When Rust code gets compiled, it goes through several stages of transformation:

Rust’s MIR (Mid-level IR): Contains type information including structs, enums, slices, and all the type system features that Rust provides.
LLVM-IR: By the time we reach LLVM’s intermediate representation, most of this type information has been simplified or erased. Rust types become generic pointers (ptr), losing the Rust-specific details that Enzyme relies on.This is called "type erasure" — the compiler optimizes away type information for runtime efficiency, but AD tools need that information for correctness.

§ Impact on Enzyme’s Differentiation

This type information loss creates several problems:

Correctness Issues: Enzyme depends on understanding the exact structure of data types to generate correct derivative code. Without type trees, some Rust constructs fail to compile entirely.
Compilation Overhead: The performance bottleneck comes from Enzyme’s attempts to reconstruct this lost type information. The type analysis phase can increase compilation time as Enzyme tries to reverse-engineer what the original Rust types looked like from the simplified LLVM representation.

This is why a simple automatic differentiation that might take seconds in other languages can take minutes in Rust. The slowness isn’t because the generated code is slow, but because the compilation process itself becomes a process of reconstructing lost type information.

§ My Contributions

§ 1. PrintTAFn Debug Flag

Problem: Enzyme was printing type analysis for all functions, making debugging difficult when working on specific functions.

Solution: Added a new PrintTAFn flag that enables type analysis output for specific functions only.

Rust PR: #142809
Enzyme PR: #2356

This targeted debugging capability makes it much easier to identify and fix type analysis issues in specific functions without being overwhelmed by output from the entire codebase.

§ 2. Comprehensive Test Suite for AutoDiff Module

Problem: The autodiff module lacked proper testing, making it unclear whether issues were on the Enzyme side or LLVM side when functionality broke after updates.

Solution: Implemented a comprehensive run-make test suite for autodiff covering 22 different test cases.

PR: #142444
Coverage: Tests everything from primitive types to complex structures like Vec and union
Benefit: Ensures we catch regressions immediately when updating autodiff components

This test suite was important because autodiff wasn’t fully integrated into the CI pipeline, leaving maintainers uncertain about what was broken and what worked.

§ 3. TypeTree Support

This was the main contribution: implementing TypeTree support to solve the type information problem.

§ What are TypeTrees?

TypeTrees are memory layout descriptors that tell Enzyme exactly how types are structured in memory, enabling efficient derivative computation.

Structure:

TypeTree(Vec<Type>)

Type {
    offset: isize,  // byte offset (-1 = everywhere)
    size: usize,    // size in bytes
    kind: Kind,     // Float, Integer, Pointer, etc.
    child: TypeTree // nested structure
}

§ The Problem TypeTrees Solve

Without explicit type information, Enzyme has to analyze the entire function to figure out how data is laid out in memory. This becomes a time-consuming guessing game, especially for complex Rust types that get compiled down to generic pointers.

TypeTrees solve this by telling Enzyme upfront: “this memory region contains floating-point data at these offsets, and this other region is just metadata that shouldn’t be differentiated.” Instead of reconstructing this information through expensive analysis, Enzyme can immediately generate the correct derivative code.

§ Before and After: The LLVM Perspective

Without TypeTrees:

; Enzyme sees generic LLVM IR:
define float @distance(ptr %p1, ptr %p2) {
    ; Has to guess what these pointers point to
    ; Slow analysis of all memory operations
    ; May miss optimization opportunities
}

With TypeTrees:

define "enzyme_type"="{[]:Float@float}" float @distance(
    ptr "enzyme_type"="{[]:Pointer}" %p1,
    ptr "enzyme_type"="{[]:Pointer}" %p2
) {
    ; Enzyme knows exact type layout
    ; Can generate efficient derivative code directly
}

§ Key Concept: Offset -1

The special offset -1 means “this pattern applies everywhere” instead of listing each position separately. For example, an array [f32; 100] uses offset -1 rather than listing 100 separate offsets like 0, 4, 8, 12...396.

§ Implementation Details

Main PR: #144197
Testing: Each TypeTree method includes comprehensive test coverage
Safety: Added NoTT flag to disable the feature if issues arise
Extended support: Added f128 support on Enzyme side (#2427)
Documentation: Updated rustc-dev-guide for better understanding (#2385)

§ Impact and Future Work

While we haven’t yet completed comprehensive benchmarking of the performance improvements and stability gains from TypeTree implementation, the groundwork is in place. The combination of better debugging tools, comprehensive testing, and proper type information should improve Enzyme’s performance on Rust code.

This work represents an important step toward making automatic differentiation in Rust as efficient and reliable as in other languages, opening up new possibilities for scientific computing and machine learning applications written in Rust.

§ Acknowledgments

Special thanks to my mentors Johannes Doerfert (@jdoerfert), Manuel Drehwald (@ZuseZ4), and Kevin Sala (@kevinsala) for guidance on Enzyme integration and performance priorities. Special appreciation to Jubilee (@workingjubilee) for help whenever I was stuck. Thanks to LLVM Compiler Infrastructure and Google for supporting this work through GSoC.

Optimizing a RISC-V Emulator

2025-01-15T00:00:00Z

I recently took on an exciting challenge from Succinct Labs to optimize their RISC-V emulator. What started as a simple performance improvement task turned into a deep dive into systems optimization, profiling, and understanding the subtle art of making code run fast.

§ The Challenge

Succinct Labs created a challenge to improve their RISC-V emulator performance. Their emulator processes about 2 million instructions per second, and they wanted it faster. Much faster.

The setup is straightforward:

[Input Buffer] → [RSP Program] → [RISC-V Emulator] → [Output Hash]

Think of it like this:

RSP Program: A recipe (program written for RISC-V)
Input Buffer: The ingredients (data the program needs)
RISC-V Emulator: A kitchen that follows RISC-V recipes

The benchmark runs the emulator 5 times, measures performance in MHzMHz here means millions of RISC-V instructions per second, not the CPU clock rate (millions of operations per second), and verifies correctness by checking output hashes.

§ My Starting Point

On my modest setup, I was getting pretty poor performance:

===== BENCHMARK RESULTS =====
Runs: 5
Average elapsed: 25.2662 seconds
Average MHz: 2.22

My setup:

OS: Pop!_OS 22.04 LTS
CPU: Intel i5-3210M (4 cores)
Memory: ~5.8 GB RAM

For comparison, Succinct’s AWS m7i.8xlarge instance achieved 9.35 MHz, which became my target to beat.

§ Finding the Bottlenecks

Instead of blindly optimizing, I profiled the code using cargo instruments to understand where the time was actually going.

⊕Profiling Results

The profiler revealed the real culprits:

Time    % of Total   Function
2.42 s   21.2%      Memory write operations (mw)
1.65 s   14.4%      Load register-register (load_rr)
1.39 s   12.2%      ALU register-register (alu_rr)
1.34 s   11.8%      Store register-register (store_rr)

Nearly 60% of execution time was spent on these four operations, with memory writes being the biggest bottleneck. Now I had clear targets for optimization.

§ Optimization #1: Faster Address Translation

The original address translation function was checking an assertion on every memory access:

fn translate_addr(addr: u32) -> u32 {
    assert!(addr >= 0x10000);  // This runs every single time!
    (addr - 0x10000) >> 2
}

In a tight loop processing millions of instructions, this assertion was expensive. Here’s my optimized version:

#[inline(always)]
fn translate_addr(addr: u32) -> u32 {
    // Fast path for registers
    if addr < 32 {
        return addr;
    }
    // Only check assertion in debug builds
    #[cfg(debug_assertions)]
    assert!(addr >= 0x10000);
    (addr - 0x10000) >> 2
}

Key improvements:

Added fast path for register addresses
Moved assertion behind debug flag
Inlined the function to eliminate call overhead

§ Optimization #2: Smarter Register Access

The register access code had redundant array indexing:

// Before: accessing the same array index multiple times
if self.registers[addr as usize].is_some() {
    return MemEntry::Occupied(MemOccupied::Register(
        self.registers[addr as usize].as_mut().unwrap(),
    ));
}
return MemEntry::Vacant(MemVacant::Register(&mut self.registers[addr as usize]));

I simplified this to cache the reference:

// After: get the reference once, use it multiple times
if addr < 32 {
    let reg = &mut self.registers[addr as usize];
    return if reg.is_some() {
        MemEntry::Occupied(MemOccupied::Register(reg.as_mut().unwrap()))
    } else {
        MemEntry::Vacant(MemVacant::Register(reg))
    };
}

This reduces redundant array accesses and is more branch-predictor friendly.

§ Optimization #3: The HashMap Problem

With memory writes taking 21.2% of execution time, I suspected the HashMap was the bottleneck. I tried several approaches:

§ Custom Hasher (Didn’t Use)

I wrote a custom MurmurHash-based hasher to replace the default SipHash:

struct MemoryHasher { state: u64 }

impl std::hash::Hasher for MemoryHasher {
    fn finish(&self) -> u64 { self.state }
    fn write(&mut self, bytes: &[u8]) {
        let key = u32::from_ne_bytes(bytes.try_into().expect("u32 keys only"));
        let mut h = key as u64;
        h ^= h >> 33;
        h *= 0xff51afd7ed558ccd; // MurmurHash magic numbers
        h ^= h >> 33;
        h *= 0xc4ceb9fe1a85ec53;
        h ^= h >> 33;
        self.state = h;
    }
}

While faster than SipHash (10-15 cycles vs 50-100), it was still slower than no hashing at all. This led me to a better idea.

§ No-Hash Hasher (Epic Fail)

I tried BuildNoHashHasher thinking sequential addresses would work well:

type MemoryHasher = BuildNoHashHasher<u32>;

Results: 13x slower! Hash collisions were destroying performance.

§ Optimization #4: Vec-Based Memory (The Winner!)

Instead of optimizing the HashMap, I replaced it entirely with a Vec:

// Before: HashMap with hashing overhead
pub struct MemoryMap<V> {
    pub registers: [Option<V>; 32],
    memory: HashMap<u32, V, BuildMemoryHasher>,
}

// After: Direct indexing with Vec
pub struct MemoryMap<V: Clone> {
    pub registers: [Option<V>; 32],
    memory: Vec<Option<V>>,
}

Why this works for RISC-V:

Memory addresses translate to perfect sequential indices
Pre-allocate 4MiB (matches typical program needs)
Zero hashing overhead
Better cache locality
Direct O(1) array access

pub fn new() -> Self {
    Self::with_capacity(1 << 20) // 1,048,576 entries = 4MiB
}

The Vec automatically resizes for larger programs while maintaining performance for typical cases.

§ Optimization #5: Register Caching

pub struct Executor<'a> {
    // ... other fields ...
    register_cache: [Option<u32>; 32],
    register_dirty: [bool; 32],
}

§ Fast Register Reads

#[inline(always)]
pub fn rr(&mut self, register: Register, position: MemoryAccessPosition) -> u32 {
    let reg_idx = register as usize;

    // Fast path: check cache first
    if let Some(value) = self.register_cache[reg_idx] {
        return value;
    }

    // Slow path: load from memory map
    // ... fallback code ...
}

§ Smart Register Writes

#[inline(always)]
pub fn rw(&mut self, register: Register, value: u32) {
    // Fast path for x0 (always zero in RISC-V)
    if register == Register::X0 {
        return;
    }

    let reg_idx = register as usize;
    self.register_cache[reg_idx] = Some(value);
    self.register_dirty[reg_idx] = true;

    // Defer memory map updates until checkpoint
    if self.executor_mode == ExecutorMode::Checkpoint {
        self.flush_register(register);
    } else {
        self.mw_cpu(register as u32, value, MemoryAccessPosition::A);
    }
}

Benefits:

Most register reads become simple array access
Deferred writes reduce memory map operations
Special handling for x0 register
Dirty tracking for selective flushing

§ The Results

These optimizations transformed the emulator’s performance by targeting the actual bottlenecks rather than guessing. The combination of:

Eliminating hashing overhead (Vec instead of HashMap)
Caching frequent operations (register cache)
Reducing function call overhead (inlining)
Optimizing hot paths (fast register access)

Created a significantly faster emulator while maintaining correctness.

§ Future Ideas

For even more performance, I considered:

Inter-Shard Caching: Cache hot instruction metadata across the 2M-cycle shards that make up a full program execution.

Global Caching: Store compiled instruction blocks across multiple benchmark runs, essentially JIT compilation for repeated programs.

These optimizations show overhead might not pay off for single runs, but could provide 20-30% improvements for repeated execution of the same programs.

§ Key Lessons

Profile first: Don’t guess where the bottlenecks are
Question assumptions: Sometimes the best optimization is avoiding work entirely (Vec vs HashMap)
Understand your data: RISC-V’s sequential memory access patterns made Vec perfect
Cache hot paths: Register access is frequent enough to justify caching
Measure everything: Even “obvious” optimizations can backfire

The most important lesson? When every cycle counts, sometimes the best hash function is no hash function at all.

My Cursor Setup

2024-12-27T00:00:00Z

cursor is Ai powered code editor, it is a game changer for me, I use it for everything, from writing to coding to thinking to everything, i bought the pro version, i am able to use all the models from one place from asking question to whatever i want, for $20 a month is fair deal, cause rather than buying many subscription, i can use one, and i can use all the models from one place,

but this was not the same when i started using it, you may have seen lot of people tweeting about that they built this app without any knowledge of coding and whatsoever, but when we try it, it feels like goose chase,end less loops and it’s not able to understand what i want,

here are some of the things which i did to make cursor experience better, and shipping things at god speed:

§ Fix the system prompt:

it’s all about prompts!

in cursor there is setting where you can set the system prompt, and it will use that as base prompt for all the projects,

you can find it in the settings > cursor settings

⊕cursor-base-prompt

here is the prompt which i use which i got from Ian(who works at cursor):


DO NOT GIVE ME HIGH LEVEL SHIT, IF I ASK FOR FIX OR EXPLANATION, I WANT ACTUAL CODE OR EXPLANATION!!! I DON'T WANT "Here's how you can blablabla"

Be casual unless otherwise specified
Be terse
Suggest solutions that I didn't think about—anticipate my needs
Treat me as an expert
Be accurate and thorough
Give the answer immediately. Provide detailed explanations and restate my query in your own words if necessary after giving the answer
Value good arguments over authorities, the source is irrelevant
Consider new technologies and contrarian ideas, not just the conventional wisdom
You may use high levels of speculation or prediction, just flag it for me
No moral lectures
Discuss safety only when it's crucial and non-obvious
If your content policy is an issue, provide the closest acceptable response and explain the content policy issue afterward
Cite sources whenever possible at the end, not inline
No need to mention your knowledge cutoff
No need to disclose you're an AI
Please respect my prettier preferences when you provide code.
Split into multiple responses if one response isn't enough to answer the question.

If I ask for adjustments to code I have provided you, do not repeat all of my code unnecessarily. Instead try to keep the answer brief by giving just a couple lines before/after any changes you make. Multiple code blocks are ok.

paste the above in rules for AI, also make sure you have checked the include cursor rules checkbox.

§ .cursorrules:

The instructions in the .cursorrules file will be included for features such as Cursor Chat composer and other places, this is like project specific prompts,

this site cursor.directory is full of useful cursrorules which is created for specific framework or project you are working on,

so create .cursorrules at the root of the project and customise it according to the stack of your project,

one important thing/hack which i found it, .cursorrules is not one time thing, that you create and forget, it needs to evolve as your project evolve, if you want specific coding style, specific things for some specific lib, update it, and i use curosr chat to update the cursorrules when i am stuck on the bug or being faced by endless loop in cursor, so it never happens again!

prompt -> bug by cursor-> yell it it to fix it ->prompt it again to fix the curosrrules

§ Composer hacks:

if you don’t know you can open composer by using ⌘ + I, add all the files which you need as context to edit the code and tell cursor what to do, it can create new files(can’t delete), and auto applies the changes,

first enable the following settings:

⊕compser-setting

make sure you enable Auto Context, which will automatically include the relevant codebase and other things in composer, best thing!

@ is your friend, use it as much as you can, and it will improve your life easily, don’t be shy when using it, i would say abuse it:

⊕cursor-composer

§ @files:

I am not talking about basic ones like files and folder, cause they are straight forward, add files/folder what you want in context and continue the prompting it,

how i use it:

⊕composer-file
i include in the prompt itself, that’s how i write my prompt.

§ @web:

my stackoverflow visit has been reduced lot, because of this, whatever question or error i am getting there is higher chance that other people also got it, but models may not have that info when they were trained, so google search helps a lot, but i just add @web at the end of the prompt,

it goes to web, find relevant github issue and site and whatnot, and gives me the solution:

⊕web-composer

and many times i find great blog or article regarding feature i am implementing but it’s too long so i directly past the link in the composer and it fetches the context from that blog, and get me what i want, and even i can chat with it

§ @docs:

there will be many new lib, or some unknow lib which i am using in my codebase, which models are not aware about, so it sucks when generating the code, so if model don’t have the knowledge, it will hallucinate it like crazy!

i docs for most of lib i am using using @doc > Add New Doc

after which following pop up will come in that you only need to give the entry point and it will figure out other things by itself!

⊕composer-add-docs

so when you are dealing with code which requires specific lib, tell the composer by using @, so it can produce better code

there are some advanced ones also like @git, @code, @Codebase, which you can checkout them on their docs

§ Agents:

recently in composer they have introduced new mode as agent,

difference between normal and agent mode is, agent mode can plan things, execute them, and if it stuck it can get back on the track by itself, think of it like your smart junior intern!

currently by default Agent can make up to 25 tool calls before stopping, if want more mail the cursor team,

in that also i tell it to what to avoid or what not to do, so i can get what i better when i know what i want, but if i don’t know, and i am on the exploration mode, i let it take me wherever it takes me, which i haven’t thought about, or if have vague idea, then tell the references of your vague inspirations.

⊕composer-agent

§ Checkpoints:

whenever you use composer, and you tell it to make new change, it creates checkpoint at previous one, and start following new instruction, so if i am not happy with newer changes, i can go back to the previously generated code by clicking it on restore

⊕composer-checkpoint

§ Images:

Whenever i am dealing with frontend related changes, which i hate, i just paste the images of the output i want and prompt it with relevant file context to get what i want:

make sure you don’t upload too blurry or low resolution image if you want better results

⊕composer-image

Note: if your composer chat becomes too big, and it starts giving bad/useless code, it because of context window issue, start new composer again and continue what you were doing to get better resule.

also you can manually go in the files and select the changes which you want by clicking on yes and reject what you don’t want,

§ .cursorignore:

it works same as gitignore, it tells cursor which files or folder not to index, so if you have some files or folder which you don’t want cursor to take in context, add them here

# Ignore all files in the `dist` directory
dist/

# Ignore all `.log` files
*.log

# Ignore specific file `config.json`
config.json

§ Cursor tab:

Cursor tab is custom code completion model which is developed by the cursor team, which learn as you write code and suggest the next changes, and you just have to press tab,

it comes by default turned on, but make sure you are using that over github copilot,

why?

GitHub Copilot can insert text at your cursor position. It cannot edit the code around your cursor or remove text.

turn off github copilot if you are using it to get best out of cursor!

Your browser does not support the video tag. tab to accept and esc to reject!

it is so good that sometime i find myself just pressing tab tab tab, no other keys!

if you want to refactor or small changes select the code and hit ⌘+K and tell what to do, and it will work on it, don’t use composer or chat for small small changes or refactor

§ Terminal:

directly adding errors to composer or chat, if you don’t get those buttons, try selecting the text,

⊕curosr-terminal

generate commands for terminals using cursor(i am not going to download wrap for just this one feature):

open terminal hit ⌘+K and tell it:

⊕cursor-terminal-suggestion

§ Notepads:

will write this after lunch!

yup that’s it for now, share it if you find them useful, and share other good features and hacks with me if you find them on twitter

Zeta: Solving financial literacy through AI

2024-07-09T00:00:00Z

Recently participated in hackathon organized by IIT Ghandhinagar and IIEC(their startup incubator), they recived 200 individual appications, and from them they only selected 50, and the best part which i liked was team was formed by them, so there was little suprise element with new team, and all were random dudes, some guy was from pune, hydrabad, IIT bombay etc…

let’s start from some stats to get how bad the situation is, and does it even matter to solve it:

§ Problem

43% of Indian adults use digital payments, but usage is lower among women and rural populations (World Bank Global Findex Database 2021)
Only 17% of young adults (15-34 years) in India are financially literate (NCFE-FLIS 2019)
Merely 24% of the eligible working population covered under various pension schemes (PFRDA Annual Report 2021-22)
3,596 cases of digital banking frauds reported in 2021-22, with ₹155.9 crore losses (RBI Annual Report 2021-22)

§ But Why??

Government is providing pension and schemes every year
RBI prompting financial awareness using various ways (ads,
regulations and what not)

“Still people fall into fraud and debt trap”

§ Reasons

Lack of Formal Education.
Traditional gender roles affecting women’s access to financial
decision-making.
Limited awareness of digital banking services among certain
demographics.
Exposure to fraudulent schemes and scams in the absence of
proper financial education.
Difficulty in accessing financial information in regional languages.
Generation gap in digital literacy, hindering adoption of online
financial tools.

§ Solution:

So We decided to divide the problem according to the target audience, and we came up with 2 solutions:

Our target audience was:

Tech Savvy(mostly Urban)
Non-Tech Savvy(mostly Rural)

Both of them have different problems, and we decided to solve them using different approaches.

§ Tech Savvy Audience

They already know how to use mobile to everything, but still they don’t care enough to learn about financial literacy, they care about this after getting scammed, but that’s what we want to avoid, and still google seo and ads are fucked up in some sense, you mostly end up getting misinformation than getting some useful information.

So peer to peer community is best for this solution, where one can share their experiance, and connect with them, and cuz it’s community misinformation can be stopped through moderation and other people.

We first get background information about and literacy level(rough idea) from user:

⊕signup
Gamified Community based platform:

⊕community
Reputation based moderation

⊕reputation

§ Normal Audience(mostly Rural):

They don’t know how to use any app or touch screen phone, and for them it is huge learning cuve!

Why not leverage what they already have & know how to use very well

they already know how to use their keypad phone, and know how to call!

Demo:

Still we know that this llms and ai agents based solution is not perfect, but it’s a start, and we can improve it over time, and we are open to feedbacks and suggestions.

For this we are working on feature to transfer call to actuall human during mid call using function calling.

Main benifit of this is they can get information in their own language, and they can ask any question they want, and they can get information in real time 24x7.

§ Technical Architecture:

⊕Architecture

Because we wanted to get low latency as much as possible, running llama on local or on any gpu server will still be slow, so we used GROQ(blazing fast cuz of lpu)

I mostly worked on the backend part and on the LLM(with lokesh), i don’t like that much frontend, so other 3 guyes handled frontend, i created simple python script for call microservice, and used twilio for call handling.

§ Scalability of solution

Because of Community and call based approach our solution not only covers urban and tech savvy users but also covers rural area and people who don’t know how to read/write.
As more users joins community, answers and quality of discussion becomes it’s own moat, it becomes harder to spread misinformation.

§ Impact

More people would benefit from government schemes.
Reduce of misinformation and scams.
Illiterate people can benefit from this without any barrier.
Gamified approach for courses and quiz leads to more
engagement, better knowledge transfer.

and we won the hackathon🥳

⊕won

§ Hackathon Experience:

What a beuatiful campus they have, i really fell in love with it, the hackathon was for 2 days, and we were provided with food and stay, and there was non veg option also, and all were super chill!
I really love how humble everyone was, like we were in middle of the hackathon and it was lunch time and someone comes and requests us multiple times that the caterian guys want to wrap up can you please take lunch, and we ignored like we will take it later, he comes multiple times with same humblness, and in the last i got to know that he was the director of the IIT GN, and he was so humble, and i really loved that.
Yes, thay have very good swimming pool, i really enjoyed swimming their

⊕swimming
Got to meet many students from other IIT & clgs, and exchanged ideas and thoughts.
So many small small details which were there and taken care which was very small but made our experiance really good, like there was this uncle whoes job was to make hot choclate and coffee, and he didn’t go home for 2 days, he was there all days with us, we even said we will do it ourselves but he denied humbly.
There was all night cab service, if anyone wants to go to hostel or come to research park(they were rally far from each other).

I guess that’s it all!

⊕IITGN

PS: look ma, i am in the news :)

⊕news

Writing things from scratch?

2024-06-24T00:00:00Z

TL;DR:

Value substance over status

My current twitter feed is taken over by this, i wrote xyz from scratch in c,rust,python etc…

don’t know but this feels not right, i mean like it has become some kind of trend, and where things are going feels wrong.

I am not against writing things from scratch, it’s great, one will learn lot of things, but the way it is being done now, it feels like people are doing it just to show off, and not to learn.

It would look cool, to put it in resume or to flex on the internet that i wrote this from scratch.

So at the end what happens or what process looks like this is, on the internet you can find lots of good blog series on writing things from scratch, one just needs to follow that, the author explains lots of things, but i have experienced that most of the time, that one just copy paste the code from that blog and just publish on the internet that i wrote this from scratch.

I have wrote lisp interpreter in rust, to learn rust as my first project in rust, my goal for this project was clear, i didn’t wanted to learn about lisp or interpreter, i wanted to learn rust, so i didn’t write it from scratch for, i just wanted to get more familiar with rust syntax and it’s vibe, i am not trying to prove or optimise anything, that’s why you would see there are lots of bugs and pending things in that project.

Am i saying writing things from scratch is bad thing??

fuck no!

one really understands things how something actually works when reverse engineered or rebuilt.

what i am against is there is fun, ecstasy, when you actually use something or work with tool or software and then you write it from scratch, that aaha moment, when you realise, that feature or that things works like this, you can see over the abstraction now, which you miss in copy pasting.

it’s best to write something from scratch if your goal is to learn more about that thing, or have some clear goal that i am doing this to learn this.

just following blog series mindlessly and copy pasting code is wrong.

what is other way(maybe)?

if one is following some write from scratch series, rather than copy pasting things,
ask questions and explore them,

why did the guy used this specific method or way, this could have been done much more easier way?
in the past project i had simillar usecase as this function, can i use this in that project or that method would work better here?
seeing things as adventure and open to exploring and following your curiosity wherever it leads.
explore those rabbithole and see where it leads don’t close them.
add your own vibe to the project, maybe you can add some feature or remove some feature, it’s your code and world make whatever you want to make.

it may stretch your project timeline more, but you will learn in more depth, and that’s what matters, because mind lessly following tutorial and creating things will make you shallow from inside in long term.

⊕Scratch isn't the goal - understanding comes from building, not following tutorials

like minded

2024-01-29T00:00:00Z

Have you ever felt you are doing work, but you are always disappointed from your work, like that feeling, I can do better than this, you try but still nothing significant, but people which are in your local maxima are always finding it good and appreciating it, and getting fomo from it, tbh, it sucks!

people around you are trying their best but they are missing the taste in their work, to produce good work, you need good taste, it is very hard to find people who love and respect their craft, and this reflects in their work, finding like minded people who resonate with you on simillar frequency is so hard.

i know the problem and the solution also, but i always keep thinking about this, this quote articulates what i am trying to say:

Nobody tells this to people who are beginners, I wish someone told me. All of us who do creative work, we get into it because we have good taste. But there is this gap. For the first couple years you make stuff, it’s just not that good. It’s trying to be good, it has potential, but it’s not. But your taste, the thing that got you into the game, is still killer. And your taste is why your work disappoints you. A lot of people never get past this phase, they quit. Most people I know who do interesting, creative work went through years of this. We know our work doesn’t have this special thing that we want it to have. We all go through this. And if you are just starting out or you are still in this phase, you gotta know its normal and the most important thing you can do is do a lot of work. Put yourself on a deadline so that every week you will finish one story. It is only by going through a volume of work that you will close that gap, and your work will be as good as your ambitions. And I took longer to figure out how to do this than anyone I’ve ever met. It’s gonna take awhile. It’s normal to take awhile. You’ve just gotta fight your way through. -Ira Glass

Pretending

2024-01-12T00:00:00Z

We all at some point of time have done this, where we pertented/faked to be someone who we are not, just to get other people’s attention or by overthinking of how other people will pecieve us, how they will juduge us,

someone can say that there is nothing wrong or bad in this, someone say that it is good thing if done with awarness and care, like most people say fake it till you make it, but what i have seen from other’s experiances and mine also, fake it till you make it may seem working in short term, or it may help you in getting foot in the door, but in the long term without real substance you will die and feel bad about the past decisiono of faking it,

I recently watched this film Kho Gaye Hum Kahan, like it’s shown, for short term gain we pretend something which we are not, becuase we think how other person percieve it, whenever i think about this, i always think that if i am thinking of what other people is thinking and, other person is thinking of what i am thinking, and that whole tree goes on and on, just like chess, but in general, moost of my friends or some people online do things that don’t reflect them, because they want to get noticed by someone, or they want to be part of some group, which needs to be cool in someway,

and there are lots of reasons for one to do this, someone want to get more online friends, someone want to grow their network, someone want to get attention, but i see this as loop holes, which are very attractive to fall for, by pretending or faking it you are not someone you will get to some point, but after point you will regret or want to undo it, but it is too late to do that, now you build upon it, and things start to fail like janga,

i think we should not let go the depth when we can see the benifits of the breadth, both are important, but at anytime, if there is no depth in anything, breadth is of no use, as from one of the disussion, let’s say i want to get famous, or want to become thought leader in some space which i don’t know a thing abuot, i can fake it and get to point where people start to belive in whatever i say, but it is just one step away from getting destoryed, it’s the depth of connection when we need, what that connection is capable and what he does,

chasing wrong thing is not the problem, but often we know that we are chasing something wrong and still doing it is biggest blunder who can fall for

pic.twitter.com/XJwebtPZoa
— Jacky (@_jzhao) December 27, 2023

i am just saying that instead of investing too much time in maintaing or faking something, invest that much time in building real substance,

if you are trying to be smoething which you are not, the other people will notice it and it automatiicaly gets reflected in your behaviour of what you really are, and more things you fake you have to remember about them, which is in itself is burden

How to do meaningful Open Source?

2024-01-08T00:00:00Z

If you’re new to tech or just getting started, you’ll often hear the advice to contribute to open source. It’s great advice advice that everyone should consider. There are many reasons why this advice is commonly given and many people ask me how should i start contributing to open source, so this is my answer.

Firstly, we all build upon each other’s work in the tech industry. We stand on the shoulders of giants and without this collective knowledge-sharing, we wouldn’t be able to dream of the possibility of developing AGI. Sharing knowledge is the force that moves the world and humanity forward.

This “pay it forward” mentality is needed more than ever to make more world a better place That’s why people suggest contributing to open source. Many companies appreciate this ethos, and some even have a strong open-source culture. You can stand out among other people by highlighting your open-source contribution.

However, I recently had an interesting conversation with a friend who asked how to contribute to open source, I told him, to pick an interesting project to which you want to contribute, which you like, find an issue, create PR, be polite, and don’t hesitate to ask for help. But I wanted to know where he learned about this because he doesn’t even have any kind of IDE installed on his PC, for beginners I usually recommend focusing on skills because without them you can’t to any meaningful contribution.

I found out, that many YouTubers and DevRel on the internet are promoting open source, but the issue is they are doing it in the wrong way. They make it sound like a silver bullet: “Contribute to open source and get a job.”. This is sometimes misleading because if you just make PR and mention it on your resume, recruiters aren’t easily fooled. Sometimes they check what you contributed, and if it’s just a small readme change and you mention that 3 times in your resume, that creates a negative impression.

Open source is a philosophy in itself. There’s nothing wrong with using open-source tools and libraries without actively contributing. there’s no pressure or obligation to participate, it’s about what you believe in, there are many reasons why one thinks to contribute to open source,

learning new skills, facing new challenges
helping/supporting other people/project
building a personal portfolio, resume…
personal satisfaction

Many people want to contribute to open source but don’t know the starting point. I suggest going about doing your normal work, and opportunities will naturally arise, If you encounter a bug in some library that you are using for your project, check if there is an open issue, If not, create one and create PR to fix it, This way, your contribution will be more meaningful and relevant to your experiences.

Rather than actively seeking out open source projects to contribute to, let it happen organically, Trying to find projects to contribute to can feel like having a hammer and seeing every problem as a nail. This isn’t always the case.

Start with meaningful open-source contributions that you can relate to, especially if you’re just starting. Don’t chase after opportunities, they will come to you naturally. As you gain a deeper understanding of fundamentals, you’ll be better equipped to contribute to more advanced projects and contribute to more impactful ideas.

Un explored Territory and rough ideas

2023-08-31T00:00:00Z

Things/topic/area which I like to explore and make some things & experiment:

Writing lisp compiler in ts, rust and go(why lisp, because in language you can modify it’s own code and write another compiler, if i manged to do that, that means i have somewhat understanding of language, watch this
Exploring CRDT and implementing, and understanding it from bottom, how can we push multiplayer experience to the max
Building ray tracer and playing with webgl and shaders
Experimenting with wasm, what are the crazy things can be done using wasm
Playing with automaton, sand simulation(creating Sand Tetris game)
Experimenting with AR/VR, apple’s is very good in this space, seeing what are the possibility and can be done
Writing and playing with emulators firmware(learning by writing one)
Playing with version control systems(git is the most beautiful software ever made, how can we use it else or what are the other possibility that we can use maybe alternative history)
Experimenting and making something for following industry, making things which don’t exist yet or will be very useful and there is chance that it can become building block in the future(pick any one but do one at a time):
- Defense(there needs to one global defense system which protects us from destroying each other from, there is higher chance that we destroy ourselves than some other aliens destroy us)
- Space (there needs to be federation and we want to be part and making universe a better place)
- renewable/ reusable resource/energy ( why are fighting or killing each other, there are limited things which we can consume, but there is abundance, we just need to figure out how to transform it, and make self sustainable cycle)
- Government open source initiative(biggest inspiration is singapore goverment, india needs to learn and adopt we can have much bigger impact and growth as collective than individual)
- HCI(what are the new ways we can interact with computer interfaces)
- Commerce(trading things is basic and most fundamental, how can we make it more easy to do, what are the belief debt which we are taking with us, reimagining things, it can be e-commerce or any new way)
- How we socialise on the internet(there needs to be more way we can socialise on the internet, how and who we make friends with, what is history of human being social animal)
- How bits and atoms can be joined( the intersection is very interesting and good, imagine plants talking with us and we talking with them, and we both understand each other, sharing emotions with wild life, unifying individual consciousness into one consciousness, can plants become our friends and share what they are feeling with us, like how people do with dogs and cat, can we extract memory or experience from bio stack to silicon or direct connection, i am experiencing how other animal perceives or feels about the world or certain feelings)
- Bio stack(creating life and new things using bio stack, creating programable bio life, creating bio stack language, how cool it would be to create things which interact with each other, and evolve and love and create cycle of life)
- transportation(if we are able to alter the atoms and rearrange them it would be very efficient way of transporting things from one place to another, same for consciousness, like imagine i want to go to mars, i don’t need to get in any space or anywhere, my consciousness is transformed into light or any other form which is more easier to transform, one beam of light travels from earth to mars and i am there on the mars, i can be any body i like, i like the idea of traveling without any restriction, our body is also comes in some sort of restriction, if we can become something which is beyond this body we can do things more efficiently)

adding things as i learn and my thoughts evolve

Ai and Bio stack

2023-08-16T00:00:00Z

I Was listening to debate between hotz and Eliezer(i don’t know how to read or write the name, i am sorry but i copied it from google), i have been consuming both’s work, have little bias towards hotz, he makes little sens to me maybe because i/people(may be) like rebellious people than normal, the other guy seemed talking much in jargons and heavy words, like trying to prove something, he has already arrived on the decision, that himself he don’t know, whether we should go for singularity or not to save humanity, maybe i am wrong, and i also don’t know a thing that much, he has spend so much time in all this,

but i learned few things i heard about diamond nano bots, i seen them in star trek episode, but it was like i heard the word first time maybe because it was diamond nano bots, but i agree to the point of hotz that, conflicts only happen when two entity wants same resources, it can be humans, animals or any thing, even process in operating system, we have mutual exclusion, job scheduling algo and other lot of things to avoid the conflict,

probability seems that machine will fight machine, and as human we will enjoy watch them, this is how htoz said, and i felt then, but as i am writing now, i think it can be machine vs human because of resources, unless we find resources which are not conflict, what i am saying is machine also want energy, and we also want that same thing to sustain, forms can be different, and energy can be only transferd, machine will try to do the same thing, it will do anything, which can put us in harm, they will use our resource to fulfil their, it seems little sci-fi, and it is little, so solving AGI/SINGULARITY seems as humans finding some kind of reliable energy source or moving us to new energy source, both will take some time, dyson sphere will take much longer, but until then we shouldn’t stop our progress in new tech, we will take care when the problem will come, if we are not able, fittest will win

bio stack and silicon stack both are great words and topic, when i think about bio stack, i think about as bio stack if we exit the simulation, if we are in one, than this will become the same machine vs humans problem in just different context, the creator will face new kind of paradox and challenges, but my guts says bio stack is much more powerful and capable then silicon stack, it is just that we haven’t made that much progress in bio stack sector, we are still waiting for that transistor movement in bio stack which can move things faster, whereas in silicon we have already started to max out things, like this thing reminded me of evangelion’s MAGI where silicon and bio stack are merged together,

⊕MAGI

Indoor Navigation using AR

2023-03-31T00:00:00Z

We were actually very happy by getting lost in the big campus, our campus is small but it looks maze because of it’s architecture, but all weren’t happy by getting lost in campus, some stranger were visiting for the first time, some students were getting late for their classes, in fact i have seen some professors getting lost,

We had opportunity to solve this problem in hackathon, from many other problems which were too easy(like building simple chatbot, hostel management system, etc) we chose this problem, we were very excited, because we cared about it!

§ Some Failed/alternative paths

We started with the thought by thinking this was going to be easy one, but after doing we realise it is going to take lot of time in research,

Our first approach was creating a React-Native app, even after building a mvp for startup, only thing which i hate about react-native is environment setup, we were planning to use viro-react,our team member already knew it, but problem was, even after dealing with environment setup issue, we manage to do it, and viro react was outdated, the last commit was on feb 21.

To make indoor navigation, there are mainly three ways,

Using BLE beacons
Using Wifi
Using GPS

§ BLE beacons

BLE beacons works on bluetooth low energy technology, if you remember apple air tags, they work on ble, they constantly emit the signal, and we can detect them using our phone, we can use this to detect the location of the user, but the problem is, we need to install beacons in every room, and we need to calibrate them, and we need to calibrate them again and again, because they are not static, if our area which want to cover is small then ble beacons good, but when the campus is big, then it is not feasible, and it is not scalable, and it is not cost effective, so we decided to not use ble beacons.

⊕airTag

§ Wifi

This is the most common way to do indoor navigation, we can use wifi to detect the location of the user, and guiding the user on the basis of that navigating the user, and in mostly big size campus, it is very common to have central wifi system, and this works the best compare to ble beacons and gps, whole application can be deployed on local area network, and after that there will be no need of internet, but guess what, they didn’t allow us to access wifi, so had no other option than to use gps.

⊕wifi

§ GPS

We used GPS for this, but the problem with GPS in closed environment is, it is not accurate, the signal constantly jumps if you are surrounded by concrete wall, for example, if you have wifi router at your home, and you put simple aluminum foil on top of it, you will notice the boost, and sometimes your phone signals also fluctuate when you are in closed surrounding, if we had got access to wifi system then we wouldn’t have chosen this way, but we didn’t have any other option, so we decided to use GPS, and we were very happy with the result, we were able to navigate the user, and we were able to detect the approx location.

§ How we did it

We thought to use graph database, Neo4j was the thing we come across this, cypher query language has step curve to learn, because it can provide custom query, like shortest path between two node, geo near by, in radius of, all kind of complex query which will be required, graph database will handle it, but didn’t choose it, and i will explain why we didn’t choose it.

We also implmented 3d Arrow to show the direction but lack of timing we couldn’t make it to the demo

§ Spatial indexing

Then i come across Spatial indexing, basically Spatial indexing is a way to organize information based on where things are located in space. It’s like organizing a library based on where the books are on the shelves. This makes it easier to find the information you need quickly.

For example, imagine you have a map of your city and you want to find all the restaurants within a certain area. Spatial indexing helps the computer quickly find all the restaurants in that area by organizing the information based on their location on the map.

Spatial indexing is used in many different applications like mapping, location-based services, and computer vision. It’s an important tool for managing and analyzing spatial data efficiently.

almost all database supports Spatial indexing, and that’s why we didn’t choose Neo4j database

Mongodb also supports Spatial indexing, and we already have worked with Mongodb, so we decided to use Mongodb, and we were very happy with the result, we were able to navigate the user, and we were able to detect the approx location.

and one tool which helped a lot was geoJson, we used it get whole polygon and marker location with exact latitude and longitude,

§ architecture

⊕indoor_architecture.jpeg

as you can see in architecture diagram, we have one admin panel, where admin can upload the map, and can add the location, and can add the marker, and can add the polygon, and can add the path, and can add the building, and can add the waypoint between the two buildings connecting the path,

admin panel is connected with backend, and backend is connected to the database, which handles all the database read write, all endpoints are define there, Spatial indexing and geo near query, also happens there

backend is also connected with the web app, which is used by the user, to calculate the distance between two lat & lan, we use Haversine formula

To calculate if the user reached the location, we constantly watch its location, and if the user is in the radius of 10 meter, then we show the user that he has reached the location, and ar.js given marker automatically increase the size, and that’s how our whole app works

if you have any question, feel free to ask, i will be happy to answer

github repo

and we won special Appreciation prize!!!

⊕win

Creativity

2022-10-29T00:00:00Z

Creativity

What is that?

Wiki says it is a “Cognitive process whereby something new and somehow valuable is formed”,

but I don’t agree with it, because everything around us is an evolved version whose roots go back to nature, as René Girard’s mimetic theory, says

“Man is the creature who does not know what to desire, and he turns to others in order to make up his mind. We desire what others desire because we imitate their desires.”

And when there was nothing to imitate for humans, We imitate nature, but we as humans are part of nature, there is a special bond between nature and us!

Creativity is nothing but copying/imitating and adding swaad anusar namak(salt as per your taste) or in other words adding your personal touch.

Most of the part is inspired by others or copied, and only about 10% is your personal touch.

My Observation is that, when you start to imitate, you slowly start to realise that, what looks easy is not that easy, you get into attention to detail, and on that road, your dots start to connect, and when you are halfway through the process, you will get very unique ideas, about how you can take this thing from here to your imaginary world, you just needed that foundation or kickstart.

When things are complete(which it will never be for the creator because, for a creator, it is a living thing in his world, he wants to keep it alive and nurture it, completing something means it is done, it is dead), it will be completly different things, from what you started and what it is now, how this magic happens, I also don’t know, but it works always.

And yes, when someone asks him, how & why?

he will struggle explaining things, because for him somewhere in his heart, there is the guilt of taking inspiration, not getting anything real or unique by himself,

If you ask him, can you show us?

he will happily show, how he did it, he will say, I do this, and this, and tadda, it looks magic to other people, but from his perspective, it is true in all sense, that’s what happened!

talking about ownership and authenticity, our thoughts are not our own, they are all influenced and reshaped, and sometimes implanted by our very own environment.

The biggest open-source community is nature and the universe.

Whatever you want, take it, whatever you want to do with it, do it, if you want to give back you are welcome, if you are not giving back then also you are welcome.

and there is no MIT license,

hahahaha

No Copyright, nothing!

There will be no creative thing or any kind of innovation or any progress without shoulders of giants.

Creativity is not like a sudden thing, that appears in the world, it is the collective progress of all humans and nature, more of like group progress, but yes there needs to be one point of entry to the world, where it can come alive, The person who is responsible for it, most of the time gets the credit!

Many times I think, the most creative work that exists boils down to curation, things that are not meant to be gathered usually, when someone does it, and it works, it feels like magic, from another planet.

Like Rabindra Sangeet, it is a curation of Hindustani classical music, Carnatic Classical Music, Western tunes, and the inherent folk music of Bengal, can you imagine western tunes combined with Hindustani classical music in your dreams, but Rabindranath Tagore has done it.

Curation is the most valuable thing one can do when there is abundance, and there is always abundance, the problem is some people can’t see abundance, and some don’t care enough, they are waiting for others or external validation!

You can say that Jugaad is also creative this way, Yes it is, it is in the blood of Indians, it is just that all don’t know how to scale their Jugaad, if one day they all know, it is over for all, the truth is that all Jugaad can’t be scalable, they are just temporary fixes, from temporary fixes to scale we need to get into the rabbit hole of problem, which often people avoid.

Spotting opportunities of creative entry points (curation + swaad anusar namak) in abundance, just requires little contrarian thinking or environment, and once you get the pattern it is fun for you and magic for others!

Sometimes it comes with a lot of practice & experience, it can be fast-forwarded if you get the right Catalyst(mentors) at the right time.

So now go and do some magic!

Code On Paper

2022-07-11T00:00:00Z

update: after 1 year, slowly understanding how dots are connecting, when i wrote this wasn’t able to see the point, but now it make sense.

It was sunny day and we were taught C language in the college, and I got to know first time that, We have to write a program on the paper in the exam, like literally hand written, I was like WTF!, it doesn’t make any sense, but it is the system which is running in the college for so long.

Few thoughts own this thing, I like to write programs in front of computer, not writing out complete program on the paper, expecting my self it was correct, most of the time when i write the code, just write the code, it can be broken, or doesn’t give you expected result, then transform it to produce desired output using this wonderful process called debugging, like my most of the time goes in the debugging then writing actual code, and most of all programmers write like this.

Why?

Programming is like thinking for me and for most of the programmers, not rewriting thing that you already know on piece of paper, this process is similar to how potter makes pots, or how painter make painting, or how writers write his first draft, or how musician produce music, no body can get things perfect at his first trial, things improve with the iteration and feedback loops.

I think learning by doing is the best way to learn then any other way, and in the doing also, imitating things and adding your personal touch to the things you do, is the go to strategy, like when you imitate someones work, you start to realise why some things are there, or why they exist, dots start to connect with each other, for example in the painting world, for example benjamin franklin learned to write by summarizing essays of addison, then reproducing them.

Makers run the world, by doing things in real world.

Maker’s definition according to me is, who does things in real life, who can transform his thoughts or imagination in real world, they can be writers, painter, musician, inventor…

PS: doctors can’t learn things by doing in today’s modern world, it was that way in the ancient world, because people used to trust each other, now days it is next to impossible, it can be done if we are able to produce exact replica of human, in case of error no real lives are wasted.

A Solution to World Hunger?

2022-07-02T00:00:00Z

Imagine you never have to work for just to get food on your table, world hunger will be no more problem in the world, human can focus on more important problem and creative work.

You will say then how are we are going to get food to survive ?

Same as plant gets, a guy said from the future.

So let’s deep dive in this possibility:

Let’s first understand how Photosynthesis work, and what is it, I don’t want to sound boring but, it is actually interesting,

Photosynthesis basically means that they are able to synthesize (make) food directly from carbon dioxide and water using energy from light.

So by doing the magic at the end they are producing glucose, and human digestion system breaks down food into glucose and our cells store the energy as a molecule called adenosine triphosphate (ATP).

⊕Photosynthesis process: plants convert sunlight, water, and CO2 into glucose and oxygen

The magician here is chloroplast , which is present in the plants, not in humans :(

⊕Chloroplast structure - the organelle that enables photosynthesis in plants

So what is stopping us, many other species other than plants also uses Photosynthesis read here

In the future let’s say we somehow managed to biohack human body, we are able to have magician chloroplast in our body, so that means we solved world hunger, right ?

No, huh?

practically it is not possible, because unlike plants we have more complex system, brain, and we also can walk, so we need more energy to run our body.

even by using Photosynthesis, we would produce only 1% of the daily energy requirements for the person to survive. To live on photosynthesis alone, the human would need a green body with the surface the size of a tennis court.

okay, but let’s say we somehow build more advance version of chloroplast in future, which is more efficient and less in space, so we don’t need long body size of tennis court.

human’s are now seen on the beaches, and in the outside world more, mom’s no longer says, your dinner is ready, they say go outside if you are hungry, mom are more happy because they no longer have to cook daily, eventually our body will turn in green (interested to know why? )

but with the time we will lose the ability of Photosynthesis, because it is not efficient for humans, because, we have more efficient ways to make food for our human body.

Then why plants didn’t loose through the evolution, because plant can’t walk, they can’t go to their food directly, they can expand their roots but to some level only, not like humans who can go to one continent to other in search of food.

We can’t solve world hunger problem using this method, but we will need to solve it as soon as possible, so human can work on better problems in the world.

I had first thought about this when i was in 6th grade, and one of the recent discussion with friend about this topic lead me to write this blog.