Tagged articles
Fiber
50 articles · Page 1 of 1
This article explores how React's key prop works internally, tracing its path from JSX to ReactElement and Fiber, and detailing the three-phase reconciliation algorithm that matches old and new nodes during list updates, with source code examples from React v19.2.8.
FiberReactReactElement
0 likes · 24 min read

PHP's new STF IO hooks design introduces a four-layer native async architecture integrating Poll API, IO Hooks, Operation Queues, and cross-platform completion drivers (io_uring/IOCP), enabling existing synchronous functions like curl_exec and fread to run as non-blocking coroutines without code changes.
BackendFiberIOCP
0 likes · 14 min read

This article evaluates five popular Go web frameworks—Gin, Echo, Fiber, Beego, and Chi—by detailing their ideal use cases, key features, performance characteristics, and drawbacks, helping developers choose the most suitable framework for their specific project requirements.
BackendBeegoChi
0 likes · 12 min read

Go’s concise syntax and strong concurrency make it a popular choice for web development, but its standard library lacks a full‑featured framework; this article compares five major Go web frameworks—Gin, Echo, Fiber, Beego, and Chi—detailing their use cases, features, pros, cons, and guidance on selecting the best fit for your project.
BeegoChiECHO
0 likes · 11 min read

OpenSwoole 26.2.0 introduces full PHP 8.5 compatibility, native Fiber coroutine context via zend_fiber, an io_uring‑based reactor and async file I/O engine, Xdebug step‑debugging inside coroutines, detailed event‑loop latency metrics, and numerous bug fixes and breaking changes, with upgrade instructions for PECL, Docker, and Composer.
FiberOpenSwoolePHP 8.5
0 likes · 6 min read

This article explains why web pages feel sluggish, how React Fiber’s interruptible asynchronous rendering solves the jank problem, and walks through progressively refined implementations—from a basic React demo to a full Fiber renderer with work‑loop scheduling, diffing, and performance optimizations.
Diff AlgorithmFiberJavaScript
0 likes · 19 min read

This guide introduces the PHP AsyncIO extension built on PHP Fiber and Workerman, explains its high‑performance features, shows how to install and quickly start with code examples for basic, concurrent, timeout‑controlled, and managed tasks, and provides a complete API reference and advanced usage tips.
FiberPHPasyncio
0 likes · 9 min read

This article compares the three leading Go web frameworks—Fiber, Gin, and GoFrame—by examining their routing mechanisms, middleware ecosystems, configuration options, microservice and cloud‑native support, real‑world code examples, and benchmark results to help developers choose the most suitable solution for their projects.
FiberGoGoFrame
0 likes · 9 min read

This article explains the fundamental differences between coroutines and fibers in modern PHP, covering their concepts, implementation layers, scheduling, stack management, integration, and practical code examples, helping developers choose the right concurrency approach for high‑performance applications.
ConcurrencyFiberPHP
0 likes · 10 min read

Wind Framework is a pure‑PHP, high‑performance coroutine framework that leverages Fibers, Workerman, and Amphp to overcome php‑fpm’s I/O bottlenecks, offering a rich set of async components such as HTTP server, DI, cache, MySQL and Redis clients, and includes simple deployment instructions.
BackendFiberPHP
0 likes · 6 min read

This article compares PHP's yield and Fiber constructs, explaining their differing stack models, usage patterns, performance trade‑offs, and how developers can decide which mechanism best fits simple iteration or complex concurrent workloads.
BackendFiberPHP
0 likes · 7 min read

The article explains the limitations of blocking I/O in traditional multi‑process servers, introduces Fibers as lightweight cooperative units, describes how to replace blocking calls with non‑blocking ones, and outlines key pitfalls such as global state and process‑affecting functions.
EventLoopFiberNonBlockingIO
0 likes · 5 min read

This guide explains Webman 5's support for Fiber, Swoole, and Swow coroutine drivers, shows how to install the required packages, configure each worker to use a specific driver, provides complete PHP code examples for Workerman and Webman, demonstrates starting the server, checking its status, and highlights compatibility constraints between Swow and Swoole.
CoroutinesFiberPHP
0 likes · 12 min read

React 16 feels smoother than React 15 because its new Fiber architecture breaks state updates into small, priority‑aware units that the Scheduler runs asynchronously, allowing high‑priority user input to render first while lower‑priority work is paused and resumed, eliminating the lag seen in full‑tree re‑renders of React 15.
FiberFront-endReact
0 likes · 16 min read

React’s core fiber system traverses a depth‑first tree using performUnitOfWork, splits rendering into beginWork and completeWork, then commits in before‑mutation, mutation, and layout phases, while hooks like useState and useEffect are implemented via linked‑list queues that ensure deterministic updates and side‑effect handling.
FiberJavaScriptReact
0 likes · 8 min read

This article explains the three key differences between using a custom React component as a JSX element versus calling it as a plain function, covering extra Fiber node creation, distinct execution timing, and how the diff algorithm treats the resulting nodes.
Component vs FunctionDiff AlgorithmFiber
0 likes · 11 min read

This article provides an in‑depth overview of React class component lifecycles before and after version 16, the new lifecycle methods, virtual DOM and diff algorithm, asynchronous rendering with Fiber, state batching, higher‑order components, render props, and error boundaries, illustrating each concept with code examples.
FiberLifecycleVirtual DOM
0 likes · 36 min read


ByteFEJan 11, 2023 · Frontend Development
This article explains how to build a lightweight React‑like library called Didact, covering its core concepts, step‑by‑step source‑code walkthrough, implementation of createElement, render, Fiber architecture, concurrent mode, and a useState hook for function components.
DidactFiberReact
0 likes · 25 min read

The article explains why React is well‑suited for cross‑platform dynamic development, detailing its data‑driven model, JSX‑to‑virtual‑DOM workflow, fiber architecture, Taro reconciler adaptations, and independent event system, and shows how React can serve as both a DSL and a full runtime for mobile and web.
FiberJSXReact
0 likes · 12 min read

The article explains how React’s data‑driven model, JSX‑to‑virtual‑DOM workflow, fiber architecture, independent event system, and adaptations such as React Native and Taro enable efficient cross‑platform dynamic applications, and provides code examples and practical guidance for developers.
FiberJSXReact
0 likes · 13 min read

The article explains how React’s data‑driven model, JSX‑to‑virtual‑DOM workflow, fiber architecture, independent event system, and adaptations in frameworks like React Native and Taro enable efficient cross‑platform dynamic applications, while comparing it with traditional template‑based approaches.
FiberJSXReact
0 likes · 13 min read

This article explains the inner workings of React DevTools, how it hooks into ReactDOM to access FiberNode structures and component data, and demonstrates a custom useDebugValueAnywhere implementation that bypasses the original hook's limitations for advanced debugging.
DevToolsFiberReact
0 likes · 8 min read

This article explains React's Diff algorithm and Fiber architecture, compares it with Vue2 and Vue3's double‑ended diff approaches, and discusses why Vue does not need Fiber or time‑slicing, providing code examples and visual illustrations of the underlying mechanisms.
Diff AlgorithmFiberFrontend Development
0 likes · 30 min read

This article explains why React function components were stateless before version 16, how the introduction of Fiber and the useState hook gave them state, and dives into the internal mechanisms—including renderWithHooks, hook queues, and update scheduling—that make state updates work in modern React.
FiberReactReact16
0 likes · 18 min read

An in‑depth walkthrough of React’s Fiber architecture reveals how time‑slicing and a linked‑list Fiber tree replace the stack‑based reconciler of React 15, delivering smoother UI updates, priority‑based task scheduling, and interruptible rendering, complete with code examples, performance comparisons, and the underlying event‑loop mechanics.
FiberReactTask Scheduling
0 likes · 12 min read

This article explains React's event system, covering how onClick events are delegated to the document, processed through synthetic events, and handled via the fiber architecture, plugin registry, and priority-based dispatching in React 16.13.1.
FiberJavaScriptReact
0 likes · 10 min read

This roundup introduces the latest releases of several open‑source projects—including ahooks 3.0 with full SSR support, Tailwind CSS v3.0’s new runtime engine, the Go‑based Fiber web framework, Happy DOM’s performance benchmarks, the low‑code front‑end framework amis, and the multi‑framework compiler Mitosis—providing concise overviews and key features for each.
FiberGoHappy DOM
0 likes · 9 min read

This article explains React 16's three‑layer architecture—Scheduler, Reconciler, and Renderer—introduces fiber nodes and trees, and details how the render and commit phases process updates using beginWork, completeWork, effect lists, and three‑step DOM mutation.
Commit PhaseFiberReact
0 likes · 13 min read

This article explains the React Fiber architecture introduced in React 16, compares it with React 15, details how Fiber nodes form a tree, and walks through the source-level implementation of the Diff algorithm, including single-node and multi-node updates, with code examples and diagrams.
Diff AlgorithmFiberFrontend Development
0 likes · 17 min read

This article examines the performance challenges of high‑concurrency Java services and demonstrates how applying reactive programming with Spring WebFlux and lightweight fibers via Quasar can dramatically reduce thread and memory overhead, improve throughput, and simplify asynchronous code.
FiberJavaQuasar
0 likes · 24 min read

This article explains the concept of requestIdleCallback, its limitations, and how React Fiber implements a custom idle‑time scheduler using requestAnimationFrame and MessageChannel, complete with code demos and analysis of the underlying React source.
FiberJavaScriptMessageChannel
0 likes · 12 min read

This article explains how React's shift from the legacy stack reconciler to the Fiber architecture and the introduction of Concurrent Mode address UI jank by slicing work, prioritizing updates, and enabling interruptible rendering, ultimately improving performance and responsiveness.
Concurrent ModeFiberReact
0 likes · 14 min read

This article provides a comprehensive overview of React's runtime optimization strategies across versions 15 to 18, explaining the evolution of its architecture, the introduction of Fiber, concurrent rendering, scheduling, priority lanes, and new APIs such as Suspense, startTransition, and useDeferredValue, while including detailed code excerpts and practical insights for developers.
Concurrent ModeFiberReact
0 likes · 35 min read


ByteFESep 22, 2021 · Frontend Development
This article walks through the evolution of React’s runtime architecture from version 15 to 18, explaining key concepts such as Fiber, Scheduler, priority lanes, concurrent mode, and new APIs like startTransition and useDeferredValue, while providing concrete code examples and visual diagrams.
Concurrent ModeFiberReact
0 likes · 36 min read

This article explains the fundamentals of browser rendering, frame lifecycle, and dropped‑frame issues, then demonstrates how React Fiber and the requestIdleCallback API can be used to split heavy tasks, improve concurrency, and keep UI interactions smooth.
ConcurrencyFiberReact
0 likes · 22 min read


ByteFEJul 15, 2021 · Frontend Development
This article explains what the Virtual DOM is, why it improves performance, how React implements it through ReactElements and Fiber, and details the diff algorithm and reconciliation process that enable efficient UI updates in modern frontend development.
Diff AlgorithmFiberReact
0 likes · 28 min read

React Fiber rewrites React’s core algorithm by breaking the diff phase into small, interruptible fiber units, scheduling them during browser idle time with requestIdleCallback, using double‑buffered trees and effect lists to pause, resume, and efficiently commit DOM updates, thereby improving UI responsiveness in large applications.
FiberFront-endJavaScript
0 likes · 28 min read

This article explains why React introduced the Fiber architecture, how it breaks rendering work into interruptible units, compares it with Vue's approach, and provides detailed code examples of Fiber's data structures, scheduling, traversal, and commit phases.
FiberJavaScriptReact
0 likes · 25 min read


JD TechMar 26, 2021 · Frontend Development
This article explains how React 16 introduced the Fiber architecture to replace synchronous VDOM rendering, using operating‑system‑style interrupt mechanisms, RequestIdleCallback scheduling and task splitting to improve rendering performance and user experience in modern browsers.
FiberInterruptReact
0 likes · 8 min read

This article explains why React introduced the Fiber architecture, how it breaks rendering work into small interruptible units, the role of requestAnimationFrame and requestIdleCallback, the underlying linked‑list data structures, and provides code examples that illustrate the render and commit phases for smoother UI updates.
FiberJavaScriptReact
0 likes · 24 min read


政采云技术Dec 29, 2020 · Frontend Development
This article explains how React 16's Fiber architecture replaces the recursive VDOM traversal with a cooperative, time‑sliced update model that splits work, uses linked‑list structures, assigns priorities, and allows tasks to be paused, resumed, or aborted for smoother rendering and better user experience.
FiberReactRendering
0 likes · 18 min read

The article explains how React’s virtual‑DOM diff can become a performance bottleneck, reviews classic optimizations such as debouncing, PureComponent, and idle callbacks, then details how the Fiber architecture makes diffing interruptible and prioritized and how the same reconciler can be leveraged to build custom cross‑platform renderers.
Custom RendererFiberFront-end
0 likes · 13 min read

This article explains React 16’s new Fiber architecture and its cooperative scheduling algorithm, showing how large diff tasks are split into small asynchronous units using priority queues and min‑heap structures, with code examples, performance visuals, and insights into real‑time and delayed task handling.
FiberHeapReact
0 likes · 20 min read

React Fiber replaces the old Stack Reconciler with a linked‑list of Fiber nodes that enable incremental, pause‑and‑resume rendering, priority scheduling, and a three‑step commit phase, allowing smoother asynchronous updates, better performance, and the foundation for Concurrent Mode and Suspense.
Concurrent ModeFiberJavaScript
0 likes · 23 min read

This article explains how browser refresh rates affect React rendering, breaks down the tasks performed in a single frame, and introduces the Fiber architecture that enables interruptible, incremental updates for smoother user experiences.
FiberReactperformance
0 likes · 16 min read

This article dissects the inner workings of React's useEffect hook by tracing its implementation through the React Fiber architecture, from mountEffect and updateEffect functions to the commit phase, revealing how side‑effects are scheduled, created, and cleaned up in modern React applications.
FiberJavaScriptReact
0 likes · 18 min read

The article explains how React Node Desktop (RND) combines React JS, Node.js, and a native UI engine to enable lightweight, cross‑platform desktop apps, then details React Fiber’s architecture—its tagging, workloop, update and commit phases—and describes RND’s JS‑native messaging, bundle splitting, animation support, and future relevance for JavaScript‑driven desktop UI.
FiberJavaScriptRND
0 likes · 11 min read

This article explains why React Fiber was introduced, describes its core concepts such as the fiber tree, work‑in‑progress tree, double buffering, priority scheduling, and lifecycle changes, and summarizes the new capabilities it brings to improve UI performance and responsiveness.
FiberReactScheduling
0 likes · 10 min read

At the fourth Node.js Underground Rail meetup in Nanjing, industry experts shared practical insights on server‑side component UI rendering for SEO, Java‑to‑Node migration strategies, runtime error detection using V8 monitoring, and debated the merits of async/await versus fiber‑based concurrency, concluding with lively discussions and community photos.
Async/AwaitFiberJava migration
0 likes · 8 min read

At the fourth Node.js Underground Rail meetup in Nanjing, experts shared practical insights on server‑side rendering, Java‑to‑Node migration, runtime error monitoring, fiber engine refactoring, and debated async/await versus fiber, providing valuable lessons and resources for modern backend development.
FiberJava migrationNode.js
0 likes · 7 min read
