Sessions List

Every truly great app the ones that feel alive, fluid, and effortless hides a quiet superpower under the hood: RenderSlivers. But let’s be honest. Most developers avoid them. They seem complex, intimidating, and a little unpredictable. We did too. Until we had to build and optimize screens that could handle massive dynamic layouts instantly and more importantly, make them server driven at Digia In this session, we’ll share our personal journey from fearing Slivers to mastering them. You’ll see how understanding Flutter’s rendering pipeline unlocked a new level of performance, flexibility, and control for us, and how we now use Slivers as the foundation of Digia’s Server-Driven UI engine that powers real apps in production. We’ll talk about the “aha” moments that changed how we see RenderSliver, how we safely harness them for adaptive, data-driven layouts, and the patterns we discovered while making Slivers server-driven. By the end, you won’t just understand RenderSlivers and Slivers in genera you’ll want to use them. Because conquering them isn’t just about performance. It’s about creative freedom. 🧠 Takeaways: How RenderSlivers actually work under the hood Practical patterns for using Slivers effectively in production apps How to make Sliver-based layouts dynamic and server-driven Common pitfalls and debugging lessons from real-world use

Every Flutter app looks perfect until the system says no. In this talk, we’ll go beneath the widgets and into the real forces that make or break Flutter stability: threads, memory, and native engine loading. Drawing from real-world crashes across millions of installs including one that caused Flutter to fail before runApp() - we’ll explore how to detect, prevent, and recover from these silent killers. You’ll learn how to build apps that don’t just run - they survive. Key takeaways: Understand Flutter’s true startup flow and native dependencies. Build “health-gated” launchers for crash-proof initialization. Detect and mitigate resource exhaustion in production. Apply resilience patterns that make Flutter unstoppable at scale.

When we start with Flutter, widgets feel like magic. They cover most of our use cases—until one day the design team comes up with something that just doesn’t fit inside the widget box. That’s when CustomPainter enters the picture. In this talk, I’ll share how CustomPainter gives you complete control over the canvas and allows you to create visuals that are simply not possible with standard widgets. I’ll walk you through how I used it in a real production feature—from drawing and manipulating paths to converting an SVG into custom path data. Along the way, we’ll also touch on some simple vector concepts that make life easier when working with shapes and curves. The goal is not just to show cool graphics, but to teach you how to structure your drawing logic, how to keep performance in mind, and how to break down a complex idea into smaller, manageable pieces. By the end, you’ll feel confident about picking up CustomPainter the next time your app’s design demands something unique. I’ll also walk through my experience of implementing CustomPainter in the AMEX Lounge app, where we had to design premium card visuals and dynamic graphics that demanded pixel-perfect accuracy. From breaking down complex drawings into smaller reusable parts, to ensuring smooth performance on high-density screens, you’ll learn what it really takes to use CustomPainter effectively in production. This session is not just about code—it’s about building confidence to pick up CustomPainter when your design vision doesn’t fit inside a widget box. Key Takeaways - Clear understanding of how CustomPainter works and when it makes sense to use it. - Step-by-step process of turning SVG paths into Flutter-friendly drawings. - Easy-to-grasp vector basics that you can apply in your own code. - Practical tips on breaking complex drawings into smaller, testable parts. - Ideas and inspiration to go beyond widgets and build interfaces that stand out.

From last 2-3 years I am seeing Flutter desktop apps are stuck with single-window limitations while users expect the rich multi-window experiences they get from native desktop applications. That's finally changing with Flutter's new multi-window support, and it's simple to implement. This talk walks through transforming your existing Flutter desktop app into a multi-window powerhouse, often with just a configuration flag flip. I'll share real experiences from implementing multi-window functionality, including the gotchas nobody warns you about and the surprisingly elegant solutions Flutter provides. We'll explore practical scenarios like creating detachable tool panels, floating inspectors, and secondary displays while keeping everything responsive and bug-free. The session includes live coding demonstrations showing how window creation, state sharing, and lifecycle management actually work in practice, not just theory. 1. Discover how enabling multi-window support can be as simple as changing a flag, plus the additional setup needed for production-ready implementations. 2. Handle the complex dance of window creation, focus management, and cleanup without memory leaks or crashes. 3. Transform existing single-window apps with minimal refactoring using proven architectural patterns and incremental adoption approaches. 4. Understand the real-world performance implications of multiple Flutter views instances and optimization techniques that actually matter in production.

With Flutter's recent architectural shift, Material and Cupertino widgets have been separated into standalone packages, marking a significant change in how we approach theming and design consistency across platforms. This session delves into: Understanding the SDK Split: What does the decoupling of Material and Cupertino mean for developers? Implementing Adaptive Themes: Strategies for creating themes that respond to platform differences while maintaining a unified codebase. Leveraging Custom Themes: Building and integrating custom themes that cater to specific design requirements and user preferences. Best Practices and Pitfalls: Common challenges in theming post-split and how to navigate them effectively.

Be among the first to discover Serverpod 3, the latest evolution of the open-source backend framework built for Flutter developers who love staying in Dart. Just out of the oven, this lightning talk gives you an exclusive first look at what’s new: features that make building, scaling, and deploying full-stack Flutter apps faster, more modular, and more enjoyable than ever. Whether you’re running your own infrastructure or deploying to the cloud, Serverpod 3 pushes developer experience to a new level. Join us to see how the next generation of Serverpod helps Flutter teams ship production-grade apps with confidence and zero backend friction.

Flutter is no longer just for mobile apps, it’s becoming a viable option for building production-ready desktop applications. In this workshop, we’ll explore how to move beyond UI and craft true OS-level experiences with Flutter Desktop. You’ll see how to create custom window frames with window_manager and flutter_acrylic, add multi-window support with desktop_multi_window, keep your app running in the background using window_manager and tray_manager, and register global shortcuts with hotkey_manager. We’ll also extend Flutter with platform channels, integrate Rust via Dart FFI, and spawn external processes using Dart’s Process API. By the end, you’ll see how Flutter can give you the same level of control you expect from native desktop development, without leaving Dart behind. Key Takeaways: - Build multi-window applications with custom window frames. - Run Flutter apps in the background with system tray integration. - Register OS-level shortcuts. - Extend Flutter with platform channels and Dart FFI. - Spawn and manage external processes using Dart’s Process API.

We all test our Flutter apps to make sure they work, but how often do we test to make sure they feel right? This session shares a simple approach: test twice, once for correctness and once for performance. We will start by looking at real issues that cause performance drops in Flutter apps on mobile and web. I will demonstrate how to measure frame build times, analyze shader compilation, and identify jank using tools like Flutter DevTools, the Performance Overlay, and Flutter’s profile mode. Then we will explore how to automate those checks using performance baselines, integration tests, and CI workflows to keep your app smooth release after release. By the end of the session, you will have a clear process and set of tools to move from “it works” to “it feels great” on every screen. Key Takeaways 1. The idea of testing twice, and why correctness and performance deserve separate testing cycles. 2. How to identify and profile performance bottlenecks in Flutter apps using DevTools, the Performance Overlay, and profile mode. 3. How to turn profiling insights into repeatable checks that catch performance regressions before they affect users. 4. Simple patterns for integrating automated performance checks into CI/CD pipelines. 5. A sustainable way to ship apps that stay fast and consistent across every platform.

Everything works great on your device, but suddenly your Flutter app starts lagging, dropping frames, or stuttering on others. This talk is about those moments. I’ll break down how Flutter renders frames, why things go janky, and how you can fix (and even prevent) it. Through real examples and practical demos, I’ll share tips and tools that have helped me improve performance in production apps — and hopefully, they’ll help you too. What this talk covers: * What exactly is a “frame drop” and how Flutter’s rendering pipeline works. * The real reasons behind jank (and no, it’s not always animations!). * Using Flutter DevTools like a pro: timeline view, paint, rebuild tracking. * Common performance pitfalls: expensive widgets, async overload, layout thrashing. * Quick wins to make lists scroll smoother, images load faster, and screens render snappier. * A simple workflow to debug and stay on top of performance issues in every release. What You'll Learn: * How to spot performance red flags before your users do. * Practical steps to profile, measure, and debug janky UI. * How to make smart widget tree decisions and avoid rebuild traps. * Best practices for keeping animations smooth and interactions fluid. * How to use Flutter DevTools Timeline and Repaint Rainbow effectively. * Battle-tested advice from production apps — what works and what doesn't.

Fragment shaders in Flutter expand the horizon of building custom UIs and animations. They go beyond your day-to-day custom painters and render objects to help you create truly custom graphics and special effects for your Flutter apps and games. With control over every pixel on the screen, you can manipulate your app graphics in a variety of ways to create effects and animations that would otherwise be impossible to do without shaders like real-time image filters seen within Instagram/Snapchat or custom blur, pixellation or even custom navigation transitions for your apps and games. We'll also explore how Shaders sit at the pinnacle of graphics and how the Flutter engine uses Fragment shaders under the hood for rendering the pixels on the screen. And go into different techniques and tools combined with Custom painting, render objects and more to use Fragment shaders in your Flutter apps and games to create unique digital experiences.

Let’s be honest — building apps that “just work” offline sounds great... until you actually try it. Suddenly, you’re juggling stale data, failed syncs, confusing UX, and that one user who went offline at exactly the wrong time. In this talk, we’ll unpack the real-life challenges and pain points of building offline-first apps in Flutter — not just the theory, but what happens when your code meets the real world. We’ll walk through practical tips and proven patterns: how to manage local storage, queue user actions, handle conflicts, and design a UX that keeps people confident, even without a signal. Along the way, we’ll share lessons learned, tools that help (like Hive, Isar, workmanager, and connectivity_plus), and what not to do when going offline. Whether you’re building for global users, field workers, or just want your app to feel rock-solid, you’ll leave with a clear roadmap to make your Flutter app offline-friendly — and user-trusted.

This will be session on how to build large scale performant Application with strategy around powering most of FrotnEnd through Backend (config + APIs), Introducing new features without App Release, Reducing Client to Server Latency, Powering Experimentation at scale, Instrumentation and Observability, State Management, etc. Along with how Apps like Flipkart, PhonePe, Tata Neu, Paytm, etc are shipping features fast and reliable.

Imagine describing a screen in plain English and seeing it come to life instantly in your Flutter app. With the power of Large Language Models (LLMs), this is now possible. In this talk, we’ll explore how AI can go beyond code generation to actually generate complete Flutter UIs at runtime. You’ll learn how to leverage LLMs to produce JSON or similar declarative structures that Flutter can render on the fly. We’ll discuss how this approach enables AI-assisted app creation, personalization, A/B testing, and even dynamic screen generation without manual coding or redeploying your app. We’ll also walk through real examples, challenges, and design patterns for making AI-generated UIs practical, safe, and production-ready. Key Takeaways: - How LLMs can describe and generate Flutter UIs dynamically - Architecture for building runtime UI generation - Integrating LLMs with SDUI frameworks like Stac or Flutter genUI - Real-world challenges: validation, consistency, and UX control - The future of generative development in Flutter

Using the same computer language for both frontend and backend makes development faster and allows team members to take the role of a full-stack developer more easily. In this workshop, we will build a multi-user drawing experience with Dart, Serverpod, and Flutter and deploy it to the cloud. Serverpod is an open-source backend written in Dart for the Flutter community. After attending this workshop, you will be ready to build your first real-time server with Dart and Serverpod. You will learn how to deploy your server to the cloud and how to release a Flutter web app. Please bring your laptop with Flutter & Dart installed.

In this session, We'll unravel the mysteries behind making Flutter and native code work together like never before. Discover the reasons why developers are enchanted by Add-to-App, from its ability to reuse code across platforms to maintaining a consistent user experience. Basically, I'll talking about how you can integrate a flutter module into you existing kotlin and swift app and how you can not scrap you existing android and ios apps and still use flutter for you upcoming features. I'll guide through the steps of setting up Flutter modules, seamlessly integrating them into native code, and handling the intricate dance between the two. Expect some hands on to make this fusion process not only seamless but also delightful. Real-world examples will be our treasure map, guiding us through instances where Add-to-App has turned the ordinary into the extraordinary. By the end of our magical journey, you'll have the knowledge to infuse your app development process with the captivating charm of Flutter's Add-to-App and a case study of CRED on how they used it in their app.

Most AI integrations in mobile apps today rely on cloud APIs, introducing latency, recurring costs, and data privacy concerns. This talk demonstrates a cloudless approach: embedding quantized Small Language Models (SLMs) directly into Flutter apps using Foreign Function Interface (FFI) to call into runtimes like llama.cpp, whisper.cpp, or tflite. Attendees will see how on-device inference enables zero-latency, privacy-first, and cost-free AI interactions. We’ll explore the full technical pipeline - model quantization (INT4/INT8), memory optimization strategies for mobile devices, FFI bindings in Dart, and integrating offline STT/TTS for seamless conversational experiences. By the end, Flutter developers will understand how to build production-ready apps that run advanced AI locally without relying on the cloud. Key Takeaways 1.Learn how to quantize and embed SLMs (INT4/INT8) into Flutter apps for on-device inference. 2.Understand how to bridge Flutter with C/C++ runtimes like llama.cpp, whisper.cpp, and tflite using FFI. 3.Explore architectural strategies for offline-first, zero-latency AI pipelines in Flutter. 4.Gain practical techniques to optimize model performance under mobile constraints (memory, CPU, battery). 5.See how cloudless AI directly addresses latency, privacy, and cost - the hardest problems in deploying AI at scale.

Flutter quickly became a solid technology to use in large-scale enterprise apps. However, as projects grow over time and developers are met with tight deadlines, we stumble upon the inevitable challenges related to dealing with legacy Flutter code. This is what I experienced firsthand while working on multiple projects across various business domains. In this talk, I will walk you through some real-life examples of how Flutter codebases can deteriorate over time and how we effectively refactor them. We’ll tackle duplicated code, tight coupling, the lack of reusable widgets, chaotic state management, polyrepo workflow issues and much more. We’ll try to stay pragmatic though. As halting the development completely to do total refactoring is rarely an option, I would like to show strategies that can quickly bring real value without disrupting the work of the whole development team. Whether you’re just starting your project or inheriting an old codebase, refactoring patterns are a must. Having a deeper knowledge of them will help you create quality future-proof Flutter apps.

Dive deep into the world of Rive Animations with Flutter—a powerful combination for creating stunning, interactive user interfaces. With over a year of hands-on experience integrating Rive (formerly known as Flare) into real Flutter projects, I’ll share what truly works when building engaging motion graphics and seamless transitions. This session will go beyond the basics, focusing on practical techniques, expert tips, and lessons learned from my journey. Discover how to synchronize Rive animations with user gestures, implement complex state transitions, and elevate your app’s aesthetics with visually appealing motion graphics. Whether you’re a beginner or looking to master advanced animation flows, you’ll leave with actionable best practices and insider tricks for making your Flutter apps shine with Rive.

Humans process visual information faster than text. For e-learning apps, it's crucial to maintain that attention. Therefore, we introduced an anime character in the e-learning app to make it more interactive. This anime character was created in Unity, and the current app was under ongoing migration to Flutter. The main challenge here was integrating Unity in three layers: Unity to Flutter, and then Flutter into separate native Android and iOS apps because of on going migration. In this presentation, I will share my insights and the challenges we encountered while integrating Unity at scale, with multiple teams working independently across 50+ packages in a single mono repo Flutter app. I will cover the following topics: 1. Integrating Unity into Flutter 2. Communicating with Unity from the Flutter app 3. Integrating the Flutter app into separate native Android and iOS apps 4. Ensuring the developer workflow remains unaffected 5. Setting up continuous integration for the three-layer integration.

This session walks through how we embedded a single Rust video engine across iOS and Android in a production Flutter app. We'll cover Flutter's PlatformView to host a native GL surface, MethodChannel to control the engine (passing events), and 'flutter_rust_bridge' to stream events from Rust back to Dart. On the native side, the engine uses a unified render loop (Notan Mobile) while integrating platform decoders: Android NDK 'MediaCodec', iOS 'VideoToolbox', and Web 'WebCodecs'. We'll show how we integrate Rust with Flutter for a smooth video-playing experience. We'll close with a quick demo of a Flutter app driving Rust and receiving live events. Key takeaways for the audience: • How to structure a single Rust engine for Android/iOS/Web. • Practical Flutter integration: 'PlatformView' for native GL, 'MethodChannel' for commands, FRB for event streams. • Decoder integrations: Like 'MediaCodec' (NDK), 'VideoToolbox', 'WebCodecs', feeding a common render path. • Simple UI overlays with egui: drawing controls/overlays inside Notan's render loop

Flutter is a powerful cross-platform framework which advocates the concept - Build for any screen. However, when it comes to media casting technologies like Chromecast and AirPlay, developers often encounter complex implementation challenges on native side of things. This session will address the complexities of integrating Chromecast and AirPlay capabilities within Flutter applications. We will explore architectural nuances of these casting technologies, exploring platform-specific APIs, bridging native implementations, and creating seamless user experiences across iOS and Android devices. Key takeaways include: - Architectural strategies for handling platform-specific casting APIs - Practical implementation patterns for Chromecast and AirPlay - Error handling and user experience considerations - Real-world code demonstrations and best practices Whether you're building audio or video streaming apps, this session will equip you with the skills needed to implement the required functionality.

State management is one of the most critical decisions in any Flutter app. With multiple approaches available—BLoC, Provider, Riverpod, and more—it can be overwhelming to decide which one to use, when, and why. In this talk, I will compare the most popular state management techniques, highlighting their strengths, weaknesses, and real-world use cases. Through live examples and practical demonstrations, you’ll see how each approach works in action and learn which pattern fits different types of Flutter apps, from small interactive apps to large enterprise-level products. By the end of this session, participants will understand how to choose the right state management approach, avoid common pitfalls, and apply these patterns effectively in their projects. Key Takeaways: 1.Understand the core principles of BLoC, Provider, and Riverpod, including their architecture, workflow, and lifecycle management. 2.Learn the strengths and limitations of each state management solution, with real-world examples from production apps. 3.See live demonstrations showing how to implement each pattern for common app scenarios (UI updates, API calls, and user interactions). 4.Gain practical guidance on when to choose BLoC, Provider, or Riverpod, depending on app complexity, team size, and maintainability needs. 5.Tips for avoiding common pitfalls, like unnecessary rebuilds, poor state separation, and performance bottlenecks.

In this talk, we'll go through a real-life case of a large banking app developed by 60+ Flutter developers that started as a polyrepo project, with each Dart package being placed in a separate Git repository. As the project grew, this became more and more problematic. The development workflow started being painful, and the main branch was broken most of the time, with developers spending more time solving conflicts and figuring out how to correctly merge all their PRs rather than focusing on delivering actual business value. We're going to analyze all the pain points that we suffered and see how the polyrepo approach compares with monorepo in Flutter projects. Then I'll show you the strategy we took to execute the migration. As we couldn't afford just to hold the development completely to clean everything up, we had to develop a smarter strategy that allowed for a more seamless transition.

Refactoring time is costly. If we get the architecture right from the beginning we would never have to rework when scaling the features. This session will list out useful and lesser known architecture tips from my experience.

Dart is a great programming language for most apps. It's modern, strongly-typed, null-safe, and memory-safe. However, it is not particularly fast compared to other compiled languages. The solution for Flutter apps that require better performance for compute-heavy tasks is Dart Foreign Function Interface (FFI). FFI allows functions written in different languages to be called from Dart code. This means that most of the app can be written in Dart, but specific compute-intensive tasks can be implemented in a lower-level language like C, which can be up to 5x faster. We will cover the following topics: - What is Dart FFI? - What are the limitations of Dart FFI? - How to use Dart FFI in a Flutter app - What is the difference in performance between Dart and C in real-life examples?

Accessibility is essential for creating apps that reach every user, regardless of ability. In this session, we will share why digital inclusion is vital for a diverse audience and how Flutter developers can bake accessibility into their workflow from the very start. We will look at how to catch issues in widgets, layouts, and navigation patterns, how to align with WCAG guidelines without slowing down development, and how modern approaches (including AI-powered developer assistants) make it easier than ever to write inclusive mobile apps. End of the day learning from this talk: - A checklist of accessibility practices tailored for Flutter apps - Real code examples of detecting and fixing issues in common Flutter widgets - A practical workflow for shipping accessible apps by default - A glimpse of how upcoming developer tooling will transform accessibility testing in mobile

I will bring an app with intentional security flaws (insecure storage, poor auth), The audience will suggest will 'hack' the app by suggesting attacks. I will demo the attacks in real-time and then show the fix to them. key Takeaways: 1. The audience will be able to understand common mistakes in flutter apps that make them unsafe. 2. They will understand how hackers 'hack' into their apps using simple attacks method. 3. The audience will also learn how to fix these mistakes, which will make their apps secure.

Step into the future of home automation and interactive displays! In this hands‑on session, Shourya and Renuka will guide you through the end‑to‑end process of transforming an ordinary two‑way mirror into a “Magic Mirror” that greets you, displays real‑time information, and even carries on intelligent conversations. Whether you’re a hobbyist eager for your next Raspberry Pi project, a mobile developer curious about embedding Flutter UIs in novel hardware, or an AI enthusiast looking to bring intelligent agents into physical spaces, this talk delivers. Why Attend? Real‑World Hardware + Software See how to connect a Raspberry Pi to a Flutter app—even if you’ve never done it before. Flutter on a Smart Mirror Learn simple tricks to run your Flutter screens on the mirror’s display and keep them running smoothly. Making MagicMirror² Work for You Discover how to install and tweak the MagicMirror² software on a Pi, and solve common issues you’ll run into. Building Your Own AI Agents Learn how to create custom AI agents, orchestrate different tools, and get the exact results you want. Adding AI the Easy Way Find out how to send voice or text questions from your mirror to an AI service and get responses back, handling delays and errors gracefully. Live Demo + Ready‑to‑Use Code Watch the complete setup in action, and grab starter code you can try out right away. Speed & Security Tips Get simple advice on keeping your Pi fast, your Flutter app lean, and your AI calls secure. Take away: When you join this session, you’ll walk away with hands‑on knowledge of wiring a Raspberry Pi to drive a Flutter UI on a smart mirror, the know‑how to install and customize MagicMirror², and the skills to build and orchestrate your own AI agents for voice and text interactions. You’ll see live demos, get production‑ready starter code, and learn simple tips for keeping your system fast, secure, and reliable—so you can start building your own magical mirror right away.

Voice is becoming one of the most natural ways to interact with technology, and Flutter gives us the tools to bring it into our apps today. In this session, we’ll explore how to build a voice-enabled assistant in Flutter by combining Speech-to-Text (STT) for recognition and Text-to-Speech (TTS) for natural responses. We’ll cover the available Flutter plugins and APIs, compare cloud vs. offline solutions, and highlight pitfalls like dealing with Austrian dialect. Through live demos, you’ll see how to integrate STT and TTS into a Flutter app, structure your architecture for responsive voice interactions, and design UIs that feel intuitive when voice becomes the primary input. By the end of the talk, you’ll have the knowledge to extend your Flutter apps with conversational capabilities—whether for accessibility, productivity, or full-blown voice assistants.

Discover how Shorebird CodePush transforms the Flutter development workflow by enabling real-time code updates for both Android and iOS platforms. We'll dive deep into the challenges of traditional app update cycles and demonstrate how Shorebird offers an elegant, efficient solution. Through an engaging live demonstration, attendees will learn: How to seamlessly integrate Shorebird into existing Flutter projects The step-by-step process of creating and deploying instant updates Techniques for implementing a robust CI/CD pipeline using GitHub Actions We'll also explore Shorebird's architecture, its free-to-use model, and upcoming features that promise to further revolutionize Flutter app maintenance.

Flutter's "everything is a widget" philosophy seems simple until performance issues emerge or unexpected rebuilds cascade through your app. This talk takes you deep into Flutter's rendering pipeline, revealing how widgets, elements, and render objects work together to create buttery-smooth UIs. You'll understand the complete widget lifecycle from creation to disposal, why setState() sometimes rebuilds more than expected, how Flutter's three-tree architecture (Widget, Element, RenderObject) optimizes performance, when widgets rebuild and how to control it with const, keys, and shouldRebuild, and what happens during every frame (build, layout, paint, composite). Through live debugging with Flutter DevTools, we'll visualize the rendering pipeline in action, identify common performance anti-patterns like excessive rebuilds, diagnose layout issues using the Inspector, and implement optimization strategies that reduce frame drops. Learn to think like the Flutter framework, writing code that leverages the rendering pipeline's strengths while avoiding its pitfalls. Walk away with mental models for predicting widget behavior and debugging expertise for rendering issues. Key Takeaways: - Complete understanding of Flutter's three-tree architecture (Widget, Element, RenderObject) - Widget lifecycle phases and when each callback fires (initState, build, dispose, etc.) - How Flutter decides when to rebuild widgets and strategies to optimize rebuilds - Frame-by-frame breakdown: what happens from setState() to pixels on screen - Practical debugging techniques using DevTools to visualize and fix rendering issues