/ chasing peace and magic internet money /
Joined March 2010
- Tweets31.1K
- Following191
- Followers3.5K
- Likes2.4K
My fly just made 70% more money with the same $10,000. It found one button.
Quick recap from my last video.
The fly was doing arbitrage on Polymarket 15 minute bitcoin markets. Buy UP and DOWN together for less than $1, get $1 back.
But it ran out of money.
Every pair stayed locked until the market closed. All 10 jars full. And the best gaps of the day showed up exactly then.
3.6¢. 4.1¢. 3.2¢. 4.4¢.
It missed all four. $137 left on the table.
Here's what it didn't know.
On Polymarket you don't have to wait for the market to close.
1 UP share + 1 DOWN share can be merged back into $1. Right away.
So I gave the fly a merge press and ran the same 15 minutes again.
Same $10,000. Same news. Same 14 gaps.
Now every time it buys a pair, it drops it into the press.
Pair in. $1,000 out. Profit locked, money free again in seconds.
The jars never filled up. Capital just kept spinning.
The 3.6¢ gap it missed last time? Taken.
The 4.4¢ gap, the best one of the day? Taken.
Final result:
Without merge: 10 of 14 gaps, +$197
With merge: 14 of 14 gaps, +$334
Same money. Same gaps. +70% from one button.
This is the part most people building arb bots skip.
They think the limit is speed. Or finding gaps.
Very often the limit is that their money is stuck waiting for a market to close.
One important catch:
Merge only works when you hold both sides.
If you bought UP and the DOWN side ran away, you can't merge one leg. That money stays locked until the close.
So merge makes your capital fast.
It doesn't save you from bad fills.
Bookmark this. If your arb bot waits for every market to close, you're leaving money on the table.
hSOMEONE IS GIVING AWAY A FULL NATIVE PC PORT OF SHADOW OF THE COLOSSUS
i genuinely didn't expect a PS4 exclusive to run this clean on my own PC in one afternoon
ShadowOfTheColossus-PC.
The PS4 game's own x86-64 code runs straight on your CPU, no emulation layer slowing it down. The PS4 GPU calls get translated to Vulkan instead.
Water now has real reflections and ripples instead of looking like a flat mirror. Texture streaming is fixed so stone and walls stay sharp without crashing after a save load. Controller support covers DualShock 4, DualSense, and Xbox, with full key remapping if you'd rather use a keyboard.
Getting it running:
> grab SotC-PCzip from the Releases page and unzip it anywhere
> open SotC.exe, the launcher scans your drives on its own for the CUSA08809 game folder
> it also finds and copies the two sound modules from any shadPS4 install you already have, so audio isn't silent
> it'll offer to import an existing shadPS4 save if it finds one
> hit Jogo e saves to add your game library, then click Play
You need your own game dump and two sound modules pulled from your own console, nothing from Sony ships with this. No Python install needed either, just Vulkan 1.3 on whatever GPU you're running.
It's GPL-2.0, fully open, 52 forks already building on top of it, and this is the kind of fan port that normally gets a takedown notice before most people even hear about it.
repo link: [github.com/AjncSystem/Shadow…]
Compare that to buying a PS4 just to replay one game, or hoping a remaster ever lands on PC officially. This gets you there today, for the cost of a dump you already own.
grab this before it gets patched out of existence
PS5 Games 'Shadow of the Colossus' is now fully playable on any Windows PC.
No emulator, original game code runs directly on Windows & Vulkan translation.
Unlocked resolution, 60 FPS option, and active developer updates, It looks incredible.
- github.com/AjncSystem/Shadow…
AN OPEN SOURCE STUDIO IS GIVING AWAY A C# ENGINE FOUNDATION THAT POWERS RIMWORLD'S NEW ENGINE
tested the Kitten Space Agency build that runs directly on this. it's a real solar system at scale, not a tech demo.
it's called BRUTAL, from ahwootech. public repo, MIT-based license, 1432 stars already.
repo link: [github.com/ahwootech/BRUTAL]
the killer feature: it's not an engine, it's the foundation under one. a custom interop layer gives C# direct, low-level access to native APIs and Vulkan. no forced editor, no scene graph, no renderer baked in, by design.
what's inside:
> direct Vulkan, GLFW, Dear ImGui, FMOD, RakNet, Jolt, Box2D bindings
> unmanaged memory, job scheduling, allocation-free collections and strings
> use any NuGet package, your own architecture, your own stack
> Ludeon built their Waylith engine on it to move RimWorld off Unity
setup:
> install the .NET 10 SDK
> reference only the Brutal.* packages you actually need
> wire up Brutal.Vulkan or Brutal.OpenGl for rendering
> add Brutal.Jolt or Brutal.Box2D for physics
> build your own systems on top, there's no fixed pipeline forcing your hand
free for commercial games, no royalty cut, unlike the big three engines everyone's used to paying into. they just ask for credit.
someone else's engine is already shipping on this while you're still deciding. bookmark it before you're the last one building from scratch.
ANTHROPIC IS GIVING AWAY FULL PARALLEL AGENT CONTROL CENTER INSIDE CLAUDE CODE FREE.
Claude Code.
Assign multiple tasks at once and it spins up a separate nested session for each one automatically.
Results from every session flow back into your main conversation on their own, no manual copy-pasting.
Launch sessions in one click from your recent projects, or save folders, SSH servers, and cloud environments as ready-made configs you reuse anytime.
Each folder runs on its own Git worktree, so multiple agents edit code in parallel without stepping on each other's changes.
The sidebar shows you exactly which sessions are actively running and which ones are sitting there waiting on you, each with a live task list, a short summary of what got done, and the environment and changed files laid out clearly.
Claude even suggests the next steps itself, and you can fire them off as new one-click sessions. The /btw command spins up side questions in their own tab without derailing the task you're actually working on.
Access is already live, just open the desktop app.
/ Full docs at Claude Code's documentation
link: [code.claude.com/docs/en/desk…]
This is already rolled out, not a limited beta window, so the only thing running out is the time before everyone else is running five agents while you're still running one.
Every day you wait on this, someone else is already shipping with a full agent team instead of a single thread.
My fly found $419 of free money in 30 minutes on Polymarket.
But it could only take $282.
Not because it was slow. Not because the gaps were fake.
It ran out of jars.
Here's the part of Polymarket arbitrage nobody talks about.
When you buy both sides of a 15 minute market under $1, your money doesn't come back right away.
It stays locked until the market closes.
So I gave the fly $10,000 and 10 jars.
Every pair it buys goes into a jar. About $980 per jar. The jar stays locked until the market closes.
12:00 to 12:15 was calm. 5 gaps, 5 jars used.
At 12:15 the market closed. Every pair paid $1. All the jars opened again.
Then news hit.
From 12:15 to 12:30 gaps showed up one after another.
The fly filled jar 1, jar 2, jar 3... all the way to jar 10.
Free capital left: $237.
And then the best gaps of the day showed up.
3.6¢. 4.1¢. 3.2¢. 4.4¢.
Bigger than anything it took before.
The fly flew over the shelf. Every jar locked. No money left to buy anything.
4 gaps missed. $137 left on the table.
At 12:30 the market closed and the money came back.
But the gaps were already gone.
Same fly. Same gaps. Two bankrolls:
$10,000: +$282
$20,000: +$419
The fly wasn't short on ideas. It was short on capital.
This is why arbitrage doesn't scale the way people think.
Your profit isn't limited by how many gaps you find. It's limited by how much money you can lock at the same time.
And the best gaps always show up when everything is already locked. Because big gaps come with chaos, and chaos is when every bot is already full.
Bookmark this. If you ever build an arb bot, the first question isn't "how do I find gaps", it's "how much can I lock".
sony deleted p.t. from the store years ago, this c++ port brings it back using nothing but your own ps4 files
everyone with a PS4 copy of P.T. sitting on a console they barely use anymore knows the pain: the game is still installed, but the hardware is basically a brick you keep around for one teaser.
pt-pc is built by LoreanXavier, one dev, in spare time, with the renderer written in Vulkan and the game logic rebuilt in C++ from scratch. no game files live in the repo or the installer, it only reads what you already own.
in normal words: it is not an emulator, it is a native PC rebuild that plays your own dump of P.T. on a real gaming PC instead of a console gathering dust.
this matters if you kept a PS4 alive just for this, if you want to play it on Steam Deck, or if you want DLSS, FSR, or ray traced shadows on a teaser that originally ran at a fixed PS4 resolution.
> grab your own P.T. dump, CUSA01127 works best
> download the installer from the Releases page for Windows, Linux, or macOS
> point it at your dump folder or fake PKG
> let it copy the three archives it needs and set up a shortcut
> launch it, play from the first wake-up to the street, voice part included
1221 stars, 81 forks, all for a teaser Sony pulled off every store years ago.
repo link: [github.com/LoreanXavier/pt-p…]
save this before you forget where you saw it.
P.T. PC Port 1.0.0
A native C++/Vulkan PC port of Kojima Productions' 2014 PS4 teaser P.T. It contains no game assets, rebuilding the logic and renderer to run directly using files from your own copy of the PS4 game.
Download: github.com/LoreanXavier/pt-p…
Updates🔽
this is the first Claude Code skill that genuinely made me stop and stare at a rocket engine diagram
explaining how something works used to mean hours in Figma or After Effects, hunting references, redrawing parts, faking the motion by hand. most people just skip it and ship a wall of text instead.
Anatomy is a free Claude Code skill, 1968 stars, 149 forks, MIT licensed, that turns a one-line prompt into a full isometric figure of a real machine. describe a rocket engine, a rate limiter, a ripple tank, and Claude designs the parts, shades them, and animates the thing moving.
what it actually does:
> builds SVG figures with dozens of shaded parts in a framed card with a live readout
> adds WebGL shaders for fire, plasma, water, light
> renders true 3D with parts re-projected as you drag
> reacts to pointer and keyboard, not a static image
> exports to HTML, standalone SVG, or React components
repo link: [github.com/wheresryan22/anat…]
a freelance illustrator or motion designer doing custom interactive diagrams for docs and landing pages would run you real money per figure, and you'd wait days for revisions. this one runs in your terminal, costs nothing, no API key, no npm install.
someone's already shipping explainer pages with this while you're still staring at a blank slide deck.
Introducing Anatomy
Describe a machine in one line. Claude brings it to life.
- Interactive isometric wireframes you can rotate, inspect and explore
- WebGL shaders for fire, water, plasma and more
- Real 3D motion, with individual parts that rotate and move
Install it as an agent skill. Fully open source.
Polymarket order book showed 5,000 shares of free money.
None of it was real.
And this one mistake is extracting thousands from arbitrage devs.
Here's what spoofing looks like when you put a fly in front of it:
Bitcoin 15 minute market on Polymarket. UP at 52¢.
Then a huge wall appears on DOWN: 5,000 shares at 46¢.
52¢ plus 46¢ is 98¢ for a pair that pays $1. A clean 2¢ arb, 5,000 deep.
The fly buys 1,000 UP and flies to the wall.
The wall disappears the moment it gets there. Cancelled in milliseconds.
DOWN jumps back to 50¢. Now the pair costs 102¢.
The fly is holding a naked UP leg with no hedge.
It sells UP back and eats -$20.
That's spoofing. Orders placed to be seen, never to be filled.
Then the fly learns.
Next wall shows up on UP. 6,000 shares, even cheaper.
This time it doesn't touch it. It checks four things first:
> The wall appeared less than a second ago
> It's 20 to 30 times bigger than anything around it
> Nobody has traded a single share at that price
> The price is way better than the last real trade
Four red flags. It waits.
The wall vanishes. Nobody ever traded against it.
Then a real gap shows up. Normal size, old orders, real fills. It takes it. +$14.40.
Third wall appears on DOWN, and the fly tries a new rule:
Hit the suspicious leg first.
It goes for the wall before buying anything else. The wall vanishes again.
But this time it's holding nothing. Lost $0.
Final session: 3 fake walls, burned once, dodged twice, 2 real arbs. +$12.00.
One fake wall cost more than one real arb made.
That's the part nobody tells you about the order book.
Visible depth is not real depth.
If a wall shows up from nowhere, at a price that's too good, and nobody has ever traded against it, assume it's bait.
And if you have to take the trade anyway, hit the side that looks fake first. If it vanishes, you lost nothing.
Bookmark this before you buy into the next 5,000 share wall.
FREE MCP TOOLKIT: REVERSE ENGINEER ANY APP, NATIVE BINARY, OR ELECTRON APP WITH YOUR OWN AGENT, NO SOURCE CODE NEEDED
фтв i genuinely don't get why 21K people starred REA and most devs still haven't wired it into their agent
someone pointed their agent at a Notes app, asked it to figure out how search worked, and REA traced the actual code path and handed back the evidence. no source code, no guessing, just the agent reading the binary and JS logic directly and explaining it in plain terms.
that's the whole pitch: see a feature you like anywhere, understand exactly how it works, then build your own version.
what it actually does:
/ connects Claude Code, Codex, Cursor, Gemini CLI and other agents to real reverse engineering tools over MCP
/ inspects native binaries using your existing Hopper or Ghidra setup, or installs Hopper for you with approval
/ reads JavaScript and Electron apps straight from an extracted directory or ASAR file
/ analyzes .NET assemblies and websites the same way
/ runs fully from your terminal too, not just inside an agent
every finding comes back with the evidence behind it, so your agent isn't just guessing what a feature does, it's showing you the trace.
the real unlock is that your agent stops being limited to code you already have. it can study anyone's shipped feature and rebuild the idea for your own project.
honest catch: native binary analysis still wants Hopper or Ghidra installed, static JS analysis is the only path that needs neither.
repo link: [github.com/morluto/rea]
every day you wait, some other dev is already pointing their agent at the app you wanted to clone. bookmark this before you forget the name.
Todo el mundo está haciendo Ingeniería Inversa de programas y videojuegos con Inteligencia Artificial.
Esta herramienta para tus agentes te ayuda a hacerlo.
Se llama REA. Un MCP open source para Claude Code, Codex y Cursor: github.com/morluto/rea
ALT Interfaz de la herramienta REA para ingeniería inversa de binarios y aplicaciones.
MY FRUIT FLY ARBITRAGE BOT JUST MADE PASSIVE + $139 ON POLYMARKET
All verifiable on-chain.
Every crypto market on Polymarket looks like free money from far away.
So I let the fly decide which ones actually are.
Six 15-minute markets. BTC, ETH, SOL, BNB, HYPE, DOGE.
I turned them into six flowers. The bigger the flower, the deeper the order book.
When UP plus DOWN drops under $1, the flower blooms. That's the nectar.
The fly patrols the field and only lands where the nectar is real.
First bloom: BTC at 97.6¢, 1,400 pairs deep. It lands and sips +$28.
Then HYPE blooms at 94¢. Way bigger gap than BTC.
The fly flies over, sniffs, and leaves.
Only 60 pairs deep. That "huge" gap was worth $3.36.
Then DOGE blooms at 93¢. Too good to be true.
The fly lands and buys UP.
The DOWN orders vanish the second it fills.
One leg, no hedge. Poisoned. -$18.
After that, something changes.
BNB blooms. The fly doesn't even look.
HYPE blooms again. Ignored.
DOGE blooms again. Ignored.
It only lands on BTC and ETH now.
Final numbers:
BTC and ETH: +$152.10
All the small coins combined: -$12.75
The small markets always bloom brightest. Bigger gaps, prettier prices.
That's the bait.
A big gap on a thin book is pocket change at best, and a trap at worst. Orders get pulled, legs get stranded, and the "free money" was never there.
BTC and ETH gaps are smaller, but they're real, because the book behind them is real.
That's why every serious arb bot I've seen lives on BTC and ETH and ignores the rest.
Bookmark this before you chase the next 93¢ on a coin with 60 shares behind it.
Full breakdown in the article below.
i genuinely can't believe every memecoin trader isn't running crawlscan before they ape into a chart.
$CrawlScan is a token intelligence engine for Robinhood Chain and Solana memecoins
live here: [crawlscan.fun]
repo link: [github.com/0xPunisher/crawls…]
what it actually does for you:
/ crawls full transfer history and top holders directly on chain, no API key, no wallet connect, nothing to sign
/ excludes bonding curves, liquidity pools, lockers and routers so concentration is measured against real circulating float, not raw supply
/ flags snipers, virgin wallets with zero trading history, and tracks exactly what the deployer still holds
/ links wallets through proven on-chain connections, same buy transaction, same distributor, direct transfers, and merges them into one operator
/ catches behavioural packs too: fresh wallets entering the same block, buying near-identical amounts, with no history before launch
/ ships a Telegram bot alongside the web terminal so you can paste an address and get the verdict without leaving the chat
checking all of this by hand means pulling explorer data, mapping wallets one by one, and cross-referencing transfers for an hour before you even know if a token is worth touching.
a trading group doing this manually would need a researcher on payroll or a paid on-chain analytics subscription just to get a fraction of this coverage.
CRAWLSCAN compresses that into a few seconds, runs on 0 runtime dependencies, and ships MIT licensed.
every day you skip this, someone else is pasting the address first.
Midjourney charges you a subscription for pixels, this project gives you raw RF spectrum off a $3 chip for free
someone pointed an ESP32-S31 at an LTE signal sitting at 2.63 GHz and streamed it live over Ethernet at 40 MSa/s straight into Gqrx.
no external SDR dongle, no RTL-SDR, just the Wi-Fi radio already soldered onto the board, repurposed to capture raw I/Q samples it was never designed to expose.
that one run is the whole pitch: a chip built for Wi-Fi packets, quietly turned into a spectrum analyzer.
this works because the firmware found an undocumented debug path that connects the ADC/DAC straight to the CPU, bypassing the fixed-function Wi-Fi modem entirely. that bypass is what lets ESP-SDR grab raw radio samples instead of just parsed packets.
what the setup actually does across supported chips:
/ captures short bursts of raw I/Q and ships them to your computer over USB or UART
/ computes on-device FFTs so some chips stream compact spectra instead of raw samples
/ the ESP32-S3 streams continuous decimated I/Q over native USB, from 250 down to 15.625 kSa/s
/ the ESP32-S31 pushes up to 40 MSa/s over Ethernet or 20 MSa/s over USB, feeding SoapyESPSDR into SDR++, SDR#, Gqrx or GNU Radio
/ the ESP32-C5 even reaches into the 5 GHz band, not just 2.4
the insight here: you already own the radio. it's sitting in every ESP32 you've got in a drawer, nobody told you it could do this.
honest caveat: the S31 Ethernet/USB streaming mode is still experimental, signal quality and a DC peak artifact need work, and chips like the ESP32-P4 aren't supported at all since they lack an integrated radio.
repo link: [github.com/ESPARGOS/esp-sdr]
every week you wait, someone else is already watching spectrum you didn't know your own hardware could see. grab the firmware before this undocumented path gets patched out in some future silicon revision.
What If Your ESP32 Could Become an SDR?
ESP-SDR turns supported ESP32 boards into a small software-defined radio receiver.
It gives you access to raw IQ samples from the Wi-Fi radio, letting you see the 2.4 GHz spectrum and waterfall in a browser.
You can explore things like RF signals, spectrum analysis, IQ data and wireless interference without expensive SDR hardware.
The ESP32-C5 is even interesting here because it can work in the 5 GHz band.
A tiny development board suddenly becomes a great tool for learning RF and signal processing.
Would you try SDR on an ESP32?
you're paying for on-chain analysts and chain-forensics subs to catch wallet clusters manually
someone just made CRAWLSCAN do it for $0
i genuinely don't understand why every memecoin trader isn't running this before every ape.
it's called CRAWLSCAN, live at crawlscan.fun, MIT licensed, zero runtime deps, python 3.12 under the hood. read-only, no keys required, nothing to connect.
repo link: [github.com/0xPunisher/crawls…]
in normal words: it's a crawler that stops asking how many holders a token has and starts asking how many real people are actually behind those holders. a token can show 200 wallets while 4 people secretly control most of the float, and CRAWLSCAN is built to catch exactly that.
this matters the second before you buy. you paste a Pons V2 memecoin address on Robinhood Chain and instead of a wall of raw holder stats, you get a verdict like 20 wallets turning out to be 4 operators, with the biggest one sitting on 38% of float.
it also flags snipers from the first seconds of launch, virgin wallets with no trading history that appeared right at launch, and what the deployer is still holding versus what they already dumped.
how to run it:
> go to crawlscan.fun
> paste the token's contract address on Robinhood Chain
> let it pull the full transfer history since launch
> read the 0-100 safety score
> check the operator clustering to see which wallets are actually the same hand
the whole pipeline, from 20 wallets down to a single real concentration number, runs without you touching a single block explorer tab or opening one transaction manually.
grab this before it gets patched into something paid, this kind of read stays free for now.
CRAWLSCAN FOR ROBINHOOD CHAIN IS LIVE AND FREE FOR EVERYONW
Access: [crawlscan.fun]
Just paste token address and let the crawlers do the rest.
They'll scan every top holder for you (their every transaction and trading pattern) and rate your token by score.
No wallet connection needed.
What you see on screen:
Token
> top holders
> wallet history
> trades and transfers
> wallet relationships
> operator detection
> risk scoring and verdict
That whole chain runs in seconds because the wallet crawlers run in parallel instead of one slow address after another.
What you get at the end is not a dashboard of numbers you have to interpret. It is a sentence:
> top holders wallets scan -> 4 operators, biggest holds 38% of float
plus a 0-100 score, where 100 is the cleanest distribution.
Hard rules sit on top of the score, because an average can hide the thing that kills you:
> critical concentration forces DANGER
> detected multi wallet operators or suspicious packs cap the result at RISKY
> not enough holder activity returns TOO EARLY instead of a confident guess
That last one matters. Most tools give you a confident answer on a token that is four minutes old and has no data behind it. This one tells you it is too early.
Where it goes from here:
> multichain, same methodology across Solana and other EVM networks
> browser extension, in development, so you scan a token without leaving the page you are already trading on
> telegram bot, in development, send a contract and get the verdict back
> operator memory across launches, so the same cluster gets recognised the next time it shows up on a different token
> launch radar, watching new launches and surfacing the ones with strange holder structure before they trend
> wallet profiler, the same intelligence pointed at a single address instead of a token
> watchlists and alerts on tokens, wallets and operators
> track record, scoring the scanner against what actually happened to the tokens it scanned
Every scan makes the engine better, because every scan is another real launch to learn from.
It tells you how the supply looks. What you do with that is on you.
Repo attached in the post below.
Everyone asks why arbitrage bots don't just print millions.
This video with my fruit fly experiment is the answer.
A price on Polymarket isn't one number. It's a staircase.
UP isn't "46¢". It's 400 shares at 46¢, 600 at 47¢, 800 at 48¢, and so on up the stairs.
Same on the DOWN side.
So I gave the fly one rule: eat the cheapest UP and the cheapest DOWN together, and stop the moment a pair costs $1.
First bite: 46¢ + 49¢ = 95¢. 300 pairs. Easy money.
Then that step is gone and the next one costs more.
96¢. 97¢. 98¢. 99¢.
Every step the edge gets thinner.
Then 49¢ + 51¢ = 100¢.
The fly stops. A pair that costs $1 and pays $1 is not a trade.
Final result: 1,800 pairs, average cost 97.3¢, +$41.80 after fees.
That's it. That's all the free money the market had.
Now the part people don't want to hear.
Want 1,000,000 pairs? The whole UP side of this book has 4,300 shares.
Buy the entire book and you get 4,300 pairs at an average of 100¢.
Zero edge. And still only 0.43% of what you wanted.
This is why the arb exists and why it stays small.
The edge isn't in the price. It's in the depth.
The first 300 pairs are free money. The 4,000th pair is a donation.
So when someone tells you they run a "risk free arb bot making millions", ask them one question:
How deep is the book?
Bookmark this.
Next video, the fly fights other bots for the first step.
this is f**king insane. Meta's incubator just open sourced a free SDK that turns any ESP32 board or spare Raspberry Pi into a full Muse gadget
no proprietary hardware needed.
every maker who's tried to build a smart home gadget knows the drill. you buy some locked down hub, fight its closed firmware, and give up trying to wire in your own sensor or screen.
Muse Gadgets kills that problem.
> flash an off the shelf ESP32 board or repurpose a Raspberry Pi you already own
> hook up displays, buttons, sensors, actuators, whatever's sitting on your workbench
> add audio in and out on the ESP32 side
> let Muse handle sysadmin chores or your Home Assistant setup on the Linux side
> each SDK directory ships a README to get started and an AGENTS.md if you're coding with an AI agent
you grab an SDK token, review the Gadget SDK Terms, and your gadget pairs straight into the Muse app on iOS or Android through Settings > Devices.
repo link: [github.com/facebookincubator…]
992 stars, 163 forks, Apache-2.0 licensed, written in C. built by hackers, for hackers, warts and all: expect the occasional bricked board if you push it.
there's also a Discord where other builders are already trading setups and getting unstuck together.
bookmark this before your next weekend project idea slips away.
I'm watching $CRAWLER LARP happen live on my timeline right now and it's honestly hilarious.
Quick backstory.
A few days ago an artist posted a browser animation of little spiders crawling across a web page.
"Web crawlers". Pure art. Millions of views.
He never launched a token.
He never sold anything.
Now there are over 3 high market cap memecoins riding his clip.
One is sitting above $2M market cap. The other is at $800K, another one is over $300K now.
Neither was made by the artist.
They were made by random guys who showed up, called themselves "the devs" and started LARPing.
And they're still LARPing as I write this.
Every post is an "update".
"Open source tomorrow."
Tomorrow comes, no repo. Just another update.
And 10 minutes ago one of them posted that a fund invested $118K in his project.
Which fund? No name. No link. No announcement from the fund. Not a single proof.
Just a tweet saying "a fund invested $118K in me" and a chart going up.
Then a new post every 10 minutes telling you to buy.
Ask yourself one question.
What real builder gets $118K from a fund and then launches a memecoin and begs people to buy it every 10 minutes?
Funded devs ship. They don't shill their own chart all day.
Think about it.
The only guy who actually made the thing people are hyped about didn't launch anything.
The guys printing fees on it haven't shown one line of code.
And people keep buying, because a tweet said a fund exists.
Crypto Twitter will believe literally anything if it's posted with enough confidence.
Show the code. Show the fund.
Until then it's a LARP with a contract address.
Barnabus Notes retweeted
this is f**king insane.
CAPCOM just open sourced a .NET data engine that outruns System.Text.Json FOR FREE.
and whoever signed off on open sourcing their actual game engine tech has bigger balls than sense...
RE:Dox is the structured data engine CAPCOM built inside REX, the tech behind their next-gen game engine. it parses JSON, JSON5, CBOR, MessagePack, TOML, XML, HTML, CSV, INI, and their own DOX format into one compact token DOM, then reads, edits, converts, and serializes straight off that structure.
most .NET devs are stuck picking one of two evils: System.Text.Json is fast but its JsonDocument is read-only, so any real edit means rebuilding a managed object tree. Newtonsoft.Json is flexible but you pay for it in allocation and speed on every single request. nobody ships a tool that gives you both for nothing.
/ on canada.json, RE:Dox deserializes 1.68x faster than System.Text.Json, and 2.84x faster running in parallel
/ citm_catalog.json comes in at 1.77x faster sequential, 2.25x faster parallel, 1.62x faster on serialize
/ canada.json allocates about 2.56 MB with RE:Dox against roughly 8.53 MB for System.Text.Json
/ twitter.json still gains 1.36x on deserialize and 2.34x in parallel mode
/ the token DOM stays mutable, so you add, remove, and reorder fields without replacing the whole document
that's not a toy benchmark, that's the same engine logic CAPCOM runs internally, handed out under Apache-2.0.
repo link: [github.com/CAPCOM-TD-OSS/RED…]
a AAA studio doesn't open source its core data layer unless it's confident nothing beats it.
someone building a real-time inventory system for a Unity or Godot project swaps their serializer for this and watches GC pressure drop on the next profiler run.
every sprint you keep allocating 3x more memory than you need to, someone else already switched.
most people will scroll past a .NET benchmark post, don't be the one still fighting System.Text.Json next month.
So the fastest JSON serializer for .NET now is developed by CAPCOM as part of their game engine that powers Resident Evil / Biohazard
I did not see that coming lol
github.com/CAPCOM-TD-OSS/RED…
this is f**king insane.
CAPCOM just open sourced a .NET data engine that outruns System.Text.Json FOR FREE.
and whoever signed off on open sourcing their actual game engine tech has bigger balls than sense...
RE:Dox is the structured data engine CAPCOM built inside REX, the tech behind their next-gen game engine. it parses JSON, JSON5, CBOR, MessagePack, TOML, XML, HTML, CSV, INI, and their own DOX format into one compact token DOM, then reads, edits, converts, and serializes straight off that structure.
most .NET devs are stuck picking one of two evils: System.Text.Json is fast but its JsonDocument is read-only, so any real edit means rebuilding a managed object tree. Newtonsoft.Json is flexible but you pay for it in allocation and speed on every single request. nobody ships a tool that gives you both for nothing.
/ on canada.json, RE:Dox deserializes 1.68x faster than System.Text.Json, and 2.84x faster running in parallel
/ citm_catalog.json comes in at 1.77x faster sequential, 2.25x faster parallel, 1.62x faster on serialize
/ canada.json allocates about 2.56 MB with RE:Dox against roughly 8.53 MB for System.Text.Json
/ twitter.json still gains 1.36x on deserialize and 2.34x in parallel mode
/ the token DOM stays mutable, so you add, remove, and reorder fields without replacing the whole document
that's not a toy benchmark, that's the same engine logic CAPCOM runs internally, handed out under Apache-2.0.
repo link: [github.com/CAPCOM-TD-OSS/RED…]
a AAA studio doesn't open source its core data layer unless it's confident nothing beats it.
someone building a real-time inventory system for a Unity or Godot project swaps their serializer for this and watches GC pressure drop on the next profiler run.
every sprint you keep allocating 3x more memory than you need to, someone else already switched.
most people will scroll past a .NET benchmark post, don't be the one still fighting System.Text.Json next month.
So the fastest JSON serializer for .NET now is developed by CAPCOM as part of their game engine that powers Resident Evil / Biohazard
I did not see that coming lol
github.com/CAPCOM-TD-OSS/RED…
I let the fly trade Up & Down markets for 24 hours straight with just one rule:
double my money or i turn you off.
It never slept.
Every 15 minutes Polymarket opens a new bitcoin Up or Down market.
That's 96 markets a day, and in most of them UP plus DOWN dips under $1 for a few seconds.
One side always pays $1, so the gap is the profit.
I ran the fly through one full day, 1,000 shares a side, fees included.
It closed the day at +$2,526.03.
136 arbs. 0 losing pairs. 17 gaps lost to faster bots.
This is Time-of-Day Arbitrage, and the clock matters more than the chart:
> 01:00 to 05:00 is thin. A gap here and there, a few dollars an hour.
> At 08:30 Europe wakes up and the gaps come back.
> 13:30 to 16:00 is the US open. Volatility spikes, prices disagree, and the best hour of the day was 14:00.
> 11 of the 96 markets had no gap at all. The fly just waited.
> It never picked UP or DOWN. Not once in 24 hours.
Turns out the money isn't in being smart at the right moment.
It's in being there for every moment, including the ones you sleep through.
My take, and it's the uncomfortable one: the trader who stays up all night watching charts is competing with something that never gets tired and never guesses.
Bookmark this. Next I'll show what happens when the fly runs a full week.
Barnabus Notes retweeted
OpenAI buildt Dots behind closed doors. this repo gives you the same idea for free, self-hosted, MIT licensed.
and whoever open sourced this two days after OpenDots dropped has bigger balls than sense...
OpenDots is an open source template for always-on AI coworkers. Each one gets a name, a role, and its own computer: browser, files, terminal, all persistent across sessions.
Most AI assistants forget everything the second you close the tab. You re-explain context every morning, re-paste the same brief, re-upload the same files.
Nothing persists, nothing has its own workspace, and you can't just hand it a task and walk away.
Here's what OpenDots actually does about that:
> each Dot keeps its own browser profile and workspace files, persisted across stop and start
> ask it to draft something, it shows you the draft first, you approve or decline before it saves
> switches between chat, voice calls, and Slack, same conversation context, same tool permissions throughout
> organizes saved work into Spaces, searchable, nested subpages, full editor
> 1009 stars and 118 forks within days of release
the human-in-the-loop approval step is the part that matters: the agent pauses, you say yes or no, nothing gets saved behind your back.
one builder is already running a researcher Dot and a writer Dot side by side, one finds things, the other drafts them, both reviewed before anything touches a real document.
repo link: [github.com/CopilotKit/OpenDo…]
it's MIT licensed, alpha stage, self-hosted, and built on CopilotKit and AG-UI. every day it sits unstarred, someone else is already cloning it and shipping their own version.
grab this before it stops being a quiet alpha.