Rodrigo Pandini

[ayush🔮👨‍💻🔮 @ayushagarwal027]

Cloudflare spent 6 weeks chasing a bug in the hyper Rust HTTP library. The fix was 4 lines. 🦀

The symptom: image responses returning HTTP 200 but with truncated data : a 14.9 MB response arriving as 219 KB, no errors logged anywhere.

The root cause: a single `let _ =` in hyper's dispatch loop discarding a `Poll::Pending` signal from the flush operation. The socket buffer filled up, flush returned pending, but hyper ignored it and called shutdown anyway, dropping the remaining data silently.

What made it so hard to find:
→ Only happened in production, never with curl
→ Only triggered for large images under real concurrency
→ Disappeared when strace was broadened (slowed things just enough to shift timing)
→ All application-level logs reported success

The breakthrough came from strace : kernel-level syscall tracing, which showed shutdown being called after just one write, with 14.8 MB still in the buffer.

The bug existed in hyper across multiple major versions (0.14 through 1.8). It was invisible because most readers drain data fast enough that the socket buffer never fills. A new, faster intermediary introduced just enough backpressure to expose it.

Fix is now merged upstream in hyperium/hyper PR #4018.

A masterclass in debugging async Rust at the systems level.

🔗 https://t.co/yd3RY2mfOf

#RustLang #AsyncRust #Hyper #SystemsProgramming #Debugging #OpenSource #Cloudflare

[Damn Nature You Scary @AmazingSights]

The middle duck paid attention in physics class, while the others played around in class...

[Orhun Parmaksız 👾 @orhundev]

I'm so excited to announce a new terminal emulator! 🎉
Meet "Ratty"🐀

🧀 A GPU-rendered terminal emulator with inline 3D graphics.

🪤 Try it out: https://t.co/AUlPT6A5Bl

⭐ Source: https://t.co/TnsLmEdExE

#rustlang #terminal #ratty #ratatui #opensource

[Michael Rihani @MichaelRihani]

Porn = loneliness sold as sex
Alcohol = escape sold as fun
Drugs = numbness sold as peace
Scrolling = distractions sold as rest
Fast food = poison sold as pleasure
Luxury = emptiness sold as purpose
Smoking = addiction sold as relaxation
Notifications = control sold as importance
Social media = validation sold as friendship
Money = paper sold as value
Bitcoin = freedom sold as speculation

Don't fuel the best parts of being human with artificial substitutes.

[OranjeBTC @ORANJEBTC]

O Bloco Genesis, minerado em 3 de janeiro de 2009 por Satoshi Nakamoto, marcou o nascimento do Bitcoin e de uma nova arquitetura monetária.

Ao incluir no primeiro bloco a manchete sobre o resgate bancário de 2009, Satoshi contextualizou o Bitcoin como resposta a um sistema financeiro fragilizado por expansão monetária recorrente, endividamento estrutural e decisões centralizadas.

Desde sua origem, o Bitcoin não foi concebido como promessa de salvação ou simples “proteção”.
Ele foi desenhado como uma alternativa.

Uma alternativa a sistemas com oferta monetária elástica, ao operar com regras claras e um limite conhecido de 21 milhões de unidades.
Uma alternativa a sistemas baseados em permissão, ao permitir transações sem intermediários.
Uma alternativa à dependência institucional, ao viabilizar a custódia direta dos próprios ativos.

O Bloco Genesis é mais do que um marco técnico. Ele representa o início de um sistema monetário baseado em regras — não em exceções — oferecendo previsibilidade, verificabilidade e escolha.

Happy Genesis Block Day! 🟧

[Calvin and Hobbes Fan Account @Calvinn_Hobbes]

On December 31, 1995, Bill Watterson published the final 'Calvin & Hobbes' comic strip. #CalvinandHobbes

[Ahmad @TheAhmadOsman]

Hugging Face has released a 214-page
MASTERCLASS on how to train LLMs

> it’s called The Smol Training Playbook
> and if want to learn how to train LLMs,
> this GIFT is for you

> this training bible walks you through the ENTIRE pipeline
> covers every concept that matters from why you train,
> to what you train, to how you actually pull it off

> from pre-training, to mid-training, to post-training
> it turns vague buzzwords into step-by-step decisions
> architecture, tokenization, data strategy, and infra

> highlights the real-world gotchas
> instabilities, scaling headaches, debugging nightmares

> distills lessons from building actual
> state-of-the-art LLMs, not just toy models

how modern transformer models are actually built

> tokenization: the secret foundation of every LLM
> tokenizer fundamentals
> vocabulary size
> byte pair encoding
> custom vs existing tokenizers

> all the modern attention mechanisms are here
> multi-head attention
> multi-query attention
> grouped-query attention
> multi-latent attention

> every positional encoding trick in the book
> absolute position embedding
> rotary position embedding
> yaRN (yet another rotary network)
> ablate-by-frequency positional encoding
> no position embedding
> randomized no position embedding

> stability hacks that actually work
> z-loss regularization
> query-key normalization
> removing weight decay from embedding layers

> sparse scaling, handled
> mixture-of-experts scaling
> activation ratio tuning
> choosing the right granularity
> sharing experts between layers
> load balancing across experts

> long-context handling via ssm
> hybrid models: transformer plus state space models

data curation = most of your real model quality

> data curation is the main driver of your model’s actual quality
> architecture alone won’t save you
> building the right data mixture is an art,
> not just dumping in more web scrapes

> curriculum learning, adaptive mixes, ablate everything
> you need curriculum learning:
> design data mixes hat evolve as training progresses
> use adaptive mixtures that shift emphasis
> based on model stage and performance
> ablate everything: run experiments to systematically
> test how each data source or filter impacts results

> smollm3 data
> the smollm3 recipe: balanced english web data,
> broad multilingual sources, high-quality code, and diverse math datasets
> without the right data pipeline,
> even the best architecture will underperform

the training marathon

> do your preflight checklist or die
> check your infrastructure,
> validate your evaluation pipelines,
> set up logging, and configure alerts
> so you don’t miss silent failures

> scaling surprises are inevitable
> things will break at scale in ways they never did in testing

> vanishing throughput? that usually means
> you’ve got a hidden shape mismatch or
> batch dimension bug killing your GPU utilization

> sudden drops in throughput?
> check your software stack for inefficiencies,
> resource leaks, or bad dataloader code

> seeing noisy, spiky loss values?
> your data shuffling is probably broken,
> and the model is seeing repeated or ordered data

> performance worse than expected?
> look for subtle parallelism bugs
> tensor parallel, data parallel,
> or pipeline parallel gone rogue

> monitor like your GPUs depend on it (because they do)
> watch every metric, track utilization, spot anomalies fast

> mid-training is not autopilot
> swap in higher-quality data to improve learning,
> extend the context window if you want bigger inputs,
> and use multi-stage training curricula to maximize gains

> the difference between a good model and a failed run is
> almost always vigilance and relentless debugging during this marathon

post-training

> post-training is where your raw base model
> actually becomes a useful assistant

> always start with supervised fine-tuning (sft)
> use high-quality, well-structured chat data and
> pick a solid template for consistent turns

> sft gives you a stable, cost-effective baseline
> don’t skip it, even if you plan to go deeper

> next, optimize for user preferences
> direct preference optimization (dpo),
> or its variants like kernelized (kto),
> online (orpo), or adversarial (apo)
> these methods actually teach the model
> what “better” looks like beyond simple mimicry

> once you’ve got preference alignment,go on-policy:
> reinforcement learning from human feedback (rlhf)
> or on-policy distillation, which lets your model learn
> from real interactions or stronger models
> this is how you get reliability and sharper behaviors

> the post-training pipeline is where
> assistants are truly sculpted;
> skipping steps means leaving performance,
> safety, and steerability on the table

infra is the boss fight

> this is where most teams lose time,
> money, and sanity if they’re not careful

> inside every gpu
> you’ve got tensor cores and cuda cores for the heavy math,
> plus a memory hierarchy (registers, shared memory, hbm)
> that decides how fast you can feed data to the compute units

> outside the gpu, your interconnects matter
> pcie for gpu-to-cpu,
> nvlink for ultra-fast gpu-to-gpu within a node,
> infiniband or roce for communication between nodes,
> and gpudirect storage for feeding massive datasets
> straight from disk to gpu memory

> make your infra resilient:
> checkpoint your training constantly,
> because something will crash;
> monitor node health so you can kill or restart
> sick nodes before they poison your run

> scaling isn’t just “add more gpus”
> you have to pick and tune the right parallelism:
> data parallelism (dp), pipeline parallelism (pp), tensor parallelism (tp),
> or fully sharded data parallel (fsdp);
> the right combo can double your throughput,
> the wrong one can bottleneck you instantly

to recap

> always start with WHY
> define the core reason you’re training a model
> is it research, a custom production need, or to fill an open-source gap?

> spec what you need: architecture, model size, data mix, assistant type
> transformer or hybrid
> set your model size
> design the right data mixture
> decide what kind of assistant or
> use case you’re targeting

> build infra for the job, plan for chaos, pick your stability tricks
> build infrastructure that matches your goals
> choose the right GPUs
> set up reliable storage
> and plan for network bottlenecks
> expect failures, weird bugs,
> and sudden bottlenecks at scale
> select your stability tricks in advance:
> know which techniques you’ll use to fight loss spikes,
> unstable gradients, and hardware hiccups

closing notes

> the pace of LLM development is relentless,
> but the underlying principles never go out of style
> and this PDF covers what actually matters
> no matter how fast the field changes

> systematic experimentation is everything
> run controlled tests, change one variable at a time, and document every step

> sharp debugging instincts will save you
> more time (and compute budget) than any paper or library

> deep knowledge of both your software stack
> and your hardware is the ultimate unfair advantage;
> know your code, know your chips

> in the end, success comes from relentless curiosity,
> tight feedback loops, and a willingness to question everything
> even your own assumptions

if i had this two years ago, it would have saved me so much time

> if you’re building llms,
> read this before you burn gpu months

happy hacking

[Alexandra Semenova @alexandraandnyc]

wealth managers putting your money in an index fund

[U.S. Securities and Exchange Commission @SECGov]

Curious about crypto wallets and how to store and access crypto assets? Check out our Crypto Asset Custody Basics Investor Bulletin.
https://t.co/x4HMYMHLAe

[Mustafa @oprydai]

there’s a strange pattern you notice once you’ve built enough things:

the world isn’t held together by geniuses.
it’s held together by obsessed people who picked one weird corner of reality and refused to look away.

someone decided gears should mesh smoother.
someone decided antennas should be smaller.
someone decided metals should bend differently.
someone decided flight controllers shouldn’t drift.
someone decided compilers should stop being stupid.
someone decided batteries shouldn’t explode.

every “normal” object around you is a fossilized obsession.
a decade-long tunnel vision from some engineer you’ll never meet.

you want an edge?
find one tiny problem that bothers you more than it bothers anyone else.
then gnaw at it.

break it.
rebuild it.
live inside it.

civilization advances one fixation at a time.

[Data Science Dojo @DataScienceDojo]

📢 Hugging Face just dropped the Smol Training Playbook, a complete, open, and free guide to training small language models efficiently.

This isn’t your average blog post, it’s a full deep dive into the entire LLM training pipeline, designed to help you understand how models actually learn, step by step.

Inside, you’ll find:

- Architecture: A breakdown of attention, embeddings, and transformer internals.

- Data Pipeline: How to collect, clean, and tokenize your dataset effectively.

- Training Loops: Optimizers, schedulers, loss functions, and mixed precision training.

- Evaluation: Measuring progress with metrics like perplexity and ROUGE.

- Scaling & Deployment: How to train smaller models that still pack a punch.

It’s hands-on, code-rich, and packed with insights — the kind of guide you actually learn from.

⚡️ Reading time: around 2–3 days. So grab a notebook, clear your weekend, and lock in — this playbook’s worth it.

#HuggingFace #OpenSourceAI #SmolModels #SmolTrainingPlaybook #MachineLearning #DeepLearning #AI #ArtificialIntelligence #LLMs

[Rodrigo Pandini @rodrigopandini]

@ORANJEBTC Parabéns pelo novo Dashboard e transparência da companhia!
Existe alguma regra/instrumento legal que impeça a OranjeBTC de fazer a "diluição das ações" (follow-on primária)?
Não seria isso uma espécie de inflação? Considerando que modelo de negócio é maximizar Bitcoins/ações.

[Harsh @theharshpat]

built a sound frequency spectrum visualizer in rust from scratch 🦀

> 500 LOC
> uses Fast Fourier Transform
> @ratatui_rs (thanks @orhundev)
> terminal width based responsive design
> true RGB terminal color gradients
> multi threading and atomic types
> 60 FPS target rendering

[LeRobot @LeRobotHF]

We just released a free online robotics course! Let's make everyone robotics AI builders thanks to open-source! 🦾🦾🦾

The course will take you on a journey, from classical robotics to modern learning-based approaches, in understanding, implementing, and applying machine learning techniques to real robotic systems.

It is based on the Robot Learning Tutorial, which is a comprehensive guide to robot learning for researchers and practitioners.

It bridges theory and practice in Robotics. It's designed for people interested in understanding how machine learning is transforming robotics. Whether you're new to robotics or looking to understand learning-based approaches, this course will guide you step by step.

At the end of this course, you'll understand:
- how robots learn from data
- why learning-based approaches are transforming robotics
- how to implement these techniques using modern tools like LeRobot

🦾🦾🦾

[AstraKernel 💫 @AstraKernel]

🦀 Agoda, team migrating to Rust

- an online travel agency

> Enabled us to handle 5x more traffic & cost savings

> GitHub Copilot was also a big enabler, helping us navigate Rust’s syntax and ownership model, suggesting idiomatic code

https://t.co/x14PJJ79ti

[SkalskiP @skalskip92]

we just released RF-DETR segmentation preview

RF-DETR is 3x faster and more accurate than the largest YOLO11 when evaluated COCO segmentation benchmark

we plan to launch full family of models by the end of October

↓ fine-tuning notebook below

repo: https://t.co/6tF4mhWSs8

[Rodrigo Pandini @rodrigopandini]

https://t.co/464gllSepW

[Rodrigo Pandini @rodrigopandini]

https://t.co/2CIb3w6o0O

[Vlad Fatu @vlad_fatu]

Just submitted Gemma Rover with Lavinia Petrache to the Kaggle "Google - Gemma 3n Impact Challenge"! 🚀

Gemma 3n controls a LeKiwi robot in a Mars-like environment — all on-device, no cloud.

https://t.co/IbpeSPp3v3

📹 https://t.co/bnRbYTHgDw

@LeRobotHF @RemiCadene

[Rodrigo Pandini @rodrigopandini]

James Gallagher, Joseph Nelson. (Jul 24, 2025). Advancing State of the Art Object Detection (Again) with RF-DETR. Roboflow Blog: https://t.co/KYN65lQq1e