Day 571: My crypto journey from 0 to 7 figures

2021
> Studying in college
> Farming NFT whitelist spots on Discord
> Convinced friends to start farming with me
> Made a few thousand from Solana NFTs (Degenerate Ape Academy, Aurory, Thugbirdz)

2022
> Sybilled 3 HAPEBEAST whitelist spots and sold the NFTs for $60K profit
> Bear market wiped out NFTs
> Kept most of my portfolio in USDC

2023
> Went all-in on BTC at $18K and ETH at $1.4K
> Received a $3.6K ARB airdrop which started my airdrop arc
> Started making multiple five-figure airdrops ($BLUR, $JTO, $TIA)

2024
> Went all-in on airdrop farming
> Biggest wins: ZKsync, Tensor & Hyperliquid
> Made high five figures on $PEPE, $PNUT & $WIF
> Started my daily journal on X

2025
> Bought $TRUMP around a $600M FDV after thinking it was a scam
> Sold way too early, but still made a bag
> Graduate college, parents want me to work a 9-5
> I refuse and move abroad with 3 friends
> $LIT became my first multiple six-figure airdrop

2026
> Grew my X account to 23.8K followers
> Spending my days however I want
> Still grinding every day

It's crazy how much my life changed in just five years.

If there's one thing I've learned, it's that you can accomplish whatever you want if you're willing to work for it long enough.

This guy built an entire strategy around buying contracts for 65-90¢ and selling them for $1

Result: +$3,169 over 2 weeks of work.

There's no secret to it. It's simple:

-> Place "Yes/No" bets on extreme temperatures
-> Enter the trade only when the forecast is almost certain
-> Buy at 65-90¢
-> Wait
-> Repeat 75 times

No leverage. No hype. No crypto lottery.

Cities: Beijing, Chengdu, Shanghai, Chongqing, Wuhan.

While everyone else is chasing 100x returns in elections and sports, he checks the weather forecast every day - and takes 15-50% off every trade where the market hasn’t yet priced in the obvious.

Top 3 deals:
$1,138.25 -> $1,632.39 (+43.41%)
$564.97 -> $702.60 (+24%)
$102.95 -> $154.56 (+50%)

My friend ask me how I get rich by december 31, 2026

I said

> Open @Polymarket

> Go to $BTC ATH by

> Buy December 31, 2026 at 0.059c

> And that's all

> Now check your polymarket account in december

Making money is easy; you just need to find good opportunity. https://x.com/kar4arodon/status/2081432491748180157

Day 572: I built my own market-making bot from scratch.

My cost per $1M in volume is around $75, which means I'm farming Perpl points almost for free thanks to the current mPoints incentives.

It only took me a couple of hours to build despite having zero prior experience.

All these existing market-making tools charging 1–2 bps are an absolute scam.

SelfHostList lists around 80 open source and self-hosted apps and services.

https://github.com/Buage/SelfHostList https://x.com/tom_doerr/status/2081655044483510389

every inference engine makes the same mistake.

an inference engine like vLLM or SGLang is the software sitting between your request and the model weights. its job is to load the model onto the GPU, run your prompt through it, and stream tokens back as fast as the hardware allows.

everything it does well comes down to keeping the GPU busy doing math.

as context windows grew, engines took on cache management too, and it went into that same process. the KV cache is the model's saved understanding of tokens it has already read, and storing it, loading it back, and shuttling it between GPU and CPU all compete with attention for the same resources.

so the two take turns.

Google's TurboQuant shows how tight that constraint is. it shrinks the KV cache to 3 bits per value with no loss in accuracy, so cached blocks take up less GPU memory and travel faster out to CPU RAM or disk.

the shrinking is not free, though. something has to compress each block on the way out and decompress it on the way back, and that work runs on the same GPU that is generating tokens.

switch TurboQuant on and inference throughput drops 20%+ compared to leaving it off. the compression is not the problem, and the process it runs in is.

LMCache is an open-source solution that moves cache management into a separate process running alongside the engine. three things follow from that split.

→ the handoff is tiny. the engine sends the block IDs it needs, which are a few identifiers rather than gigabytes of data, and all the actual movement of cached vectors happens on the other side while the engine keeps computing attention.

→ both processes share GPU memory directly. passing cached state between two GPUs normally costs several copies of the data, and here they read and write the same region, so a cached document stops being duplicated per worker.

→ lookups run in parallel. cached blocks live in four places, GPU memory first, then CPU RAM, then local SSD, then cloud storage. checking them one at a time means the slowest one sets your floor, so LMCache queries all four at once and streams from whichever answers first.

that's the real shift. cache work is I/O-heavy and inference is compute-heavy, and keeping them in one process means every improvement to your caching costs you inference time.

on H200s with Qwen3-235B and 50 concurrent users, separating them gives 14x faster time-to-first-token and 4x faster decoding. startup drops from over three minutes to about 30 seconds.

@lmcache directly plugs into vLLM, SGLang, and TensorRT-LLM, runs on NVIDIA and AMD, and survives a crash on either side, with the engine falling back to uncached inference until the cache process reconnects.

check it out on GitHub: https://github.com/LMCache/LMCache

(don't forget to star 🌟)

the diagram below traces one prompt through the whole path. i wrote the full breakdown of how LMCache works, and the article is quoted below.