We Didn’t Start The Fire #44

🔥 From scalable ML systems to blazing-fast shaders and next-gen mobile frameworks, we’re diving into the hottest innovations shaping tech today.

ShareChat’s 1,000x Scalable ML Feature System

Handling large-scale ML features efficiently is hard. ShareChat engineers scaled their ML feature store from 1 million to 1 billion features per second without increasing database infrastructure. Here’s how they did it:

• Optimized Data Pipelines: They reduced data duplication and improved storage efficiency.

• Parallel Processing: Features were computed in parallel across multiple machines, reducing bottlenecks.

• Efficient Caching Strategies: By caching frequently used features, they minimized redundant computations.

• Column-Oriented Storage: Using a column-based data store, they improved retrieval speed.

This case study is a great example of cost-efficient ML scaling. (Read more)

BEncode: A Simple and Efficient Serialization Format

BEncode is a compact data format used in BitTorrent to store and transfer data efficiently. It encodes four types of data:

• Integers: Stored as i<number>e, e.g., i42e represents 42.

• Byte Strings: Stored as <length>:<string>, e.g., 4:chat represents "chat".

• Lists: Stored as l<items>e, e.g., l4:abcd3:defe represents ['abcd', 'def'].

• Dictionaries: Stored as d<key><value>e, e.g., d3:onei1e3:twol2:abe3:cde.

Here’s a basic implementation of this

It’s lightweight, easy to parse, and widely used in peer-to-peer networks where efficiency is key. (Learn more)

Lynx: TikTok’s Cross-Platform Mobile Development Framework

TikTok recently introduced Lynx, a new framework for building cross-platform mobile apps. Lynx aims to solve issues found in React Native and Flutter by offering:

• High Performance: Uses C++ for rendering, making it faster than traditional hybrid frameworks.

• Seamless Interoperability: Works across Android and iOS without extra overhead.

• Optimized for Large Apps: Built with TikTok-scale applications in mind.

This could be a game-changer for mobile development, especially for companies looking for a scalable alternative to React Native and Flutter. (Watch the video)

Using Shaders in Flutter

Fireman A came across something interesting while working on a Flutter project—fragment shaders. At first, they seemed like a mysterious way to manipulate pixels, but after digging deeper, it became clear why they’re so powerful.

What are Shaders?

Shaders are small programs that run on the GPU to handle graphics processing. Unlike normal code that runs on the CPU, shaders execute in parallel, making them super fast. They are commonly used in video games, animations, and rendering effects.

Flutter now allows developers to use fragment shaders, which control how each pixel is drawn on the screen. This opens the door to custom effects like blur, lighting, and cool animated visuals.

Why Use Fragment Shaders in Flutter?

• Offloading work to the GPU for smoother animations.

• Creating high-performance visual effects without blocking the main thread.

• Customizing UI elements beyond built-in widgets.

By leveraging fragment shaders, Flutter apps can achieve visually rich experiences with great performance. (Learn more)

ML and LLM System Design – 500 Case Studies

Machine Learning (ML) and Large Language Models (LLMs) are changing how companies operate. Evidently AI has put together a collection of 500 case studies from companies like Netflix, Airbnb, and DoorDash. These case studies show how ML is used in recommendation systems, fraud detection, NLP, and computer vision. If you’re interested in real-world AI implementations, this is a great place to start. (Evidently AI)

Flutter Performance Practices

If you want your Flutter app to feel buttery smooth, there are some key performance best practices you should follow.

• Minimize unnecessary widget rebuilds – Use const widgets wherever possible and lean on ValueListenableBuilder to rebuild only when necessary.

• Use lazy loading for large lists – ListView.builder() ensures items are only built when needed, preventing excessive memory usage.

• Move expensive work off the main thread – If you're running heavy computations, use isolates to keep the UI responsive.

• Keep your widget tree shallow – Deep widget hierarchies slow things down; keep them lean for better performance.

• Profile and optimize – Use Flutter DevTools to catch jank and unnecessary renders before they become a problem.

If you follow these practices, your app will not just work—but feel great. (Read more)