After NVIDIA announced a new round of price hikes for GPU cores and memory, the RTX 50 series faces soaring costs and delayed releases, but rapid software advances like DLSS 5, aggressive texture compression, and longer‑lasting hardware could turn the slowdown into a win for everyday gamers.
This article introduces the ez‑Tree plugin for Three.js, showing how to install it via npm or pnpm, import and instantiate the Tree class, configure position, scale, and animation updates, and customize parameters such as tree type, branch direction, and leaf density, with a link to the GitHub repository.
This article explains how to implement three complex visual effects—Strange Attractor, Fibonacci Sphere, and Galaxy animations—in Flutter using only Dart code, covering the underlying differential equations, Euler integration, 3D‑to‑2D projection, rotation, perspective, performance optimizations, and solutions to common GPU tile‑artifact issues.
This guide walks Android developers through the concepts, tools, and step‑by‑step code needed to render video frames with OpenGL ES, apply custom shaders, and optionally build a custom FFmpeg‑based player for advanced animation effects.
An in‑depth look at Linux’s DRM GPU driver framework reveals how Direct Rendering Manager, libdrm, KMS, GEM and related components collaborate to manage GPU resources, render graphics, and support multi‑display setups, complete with illustrative code examples and practical debugging tips.
This article explains how Android handles SVG-like vector graphics using VectorDrawable and AnimatedVectorDrawable, covering their XML structures, supported tags, code examples, conversion from SVG, usage in layouts, and a detailed source code walkthrough of rendering and animation processes.
This article explores why early 1980s games such as Contra could deliver rich graphics, music, and gameplay within just 128KB of memory, explaining tile‑based rendering, limited audio chip capabilities, and ultra‑compact code techniques that made such feats possible.
This article provides a step‑by‑step guide to building a realistic rain animation in Python using the Pygame library, covering environment setup, raindrop physics, drawing techniques, full source code, and suggestions for customization such as color, density, wind, and depth effects.
This article traces the history of graphics GPUs from their 1980s origins to modern AI and high‑performance computing roles, examines China's emerging GPU market and its challenges, and reviews the key graphics and compute standards shaping the industry today.
This article introduces PHP‑Raylib, the PHP binding for the Raylib game framework, outlines its key features, cross‑platform support, installation steps, and provides detailed code examples—including a basic window and a custom button—while comparing it to native Raylib.
This article explains the Linux DRM graphics framework, its three main components (libdrm, KMS, GEM), the essential elements for display pipelines, and provides step‑by‑step example programs for single‑buffer, double‑buffer, page‑flip, and plane‑based rendering, including complete source code and execution notes.
The article explains Android’s VectorDrawable format for SVG‑like scalable graphics, details its XML schema, shows how to create static vectors, gradients, and clip‑paths, then examines the underlying source‑code flow, and finally describes AnimatedVectorDrawable’s property‑based animations, inflation process, and runtime execution.
This article walks through building an eye‑catching Hero Section using Three.js, custom GLSL shaders, dynamic point lights, and post‑processing effects such as UnrealBloomPass, FilmPass, and a custom ShaderPass, providing complete code snippets and practical tips for front‑end developers.
This article provides a comprehensive overview of modern GPU architecture, covering components such as SMs, GPCs, memory hierarchy, unified shader architecture, SIMT execution, warp scheduling, and compares IMR, TBR, and TBDR rendering pipelines while offering practical optimization techniques for developers.
This comprehensive guide explains vector graphics fundamentals, the advantages of SVG, common file formats, basic shapes, path commands, text handling, gradients, image embedding, animation elements, JavaScript and CSS interactivity, and best practices for integrating SVG into modern web pages.
The article explains how Linux has overcome past installation hassles, hardware compatibility issues, and usability concerns, making it a practical and polished desktop operating system in 2025, with simplified installers, dual‑boot support, modern graphics drivers, HiDPI scaling, and easy virtualization options.
This article walks through implementing probability‑density‑function (PDF) based importance sampling in a Rust ray‑tracing renderer, covering trait definitions, concrete PDF types for spheres, cosine distributions, hittable objects, quad geometry, material adjustments, and integration into the rendering loop to achieve faster convergence and higher image quality.
This tutorial walks through building a dazzling fireworks animation in Python using the Pygame library, covering environment setup, installing dependencies via domestic mirrors, defining particle and firework classes, and implementing the main game loop with full source code examples.
This guide explains that the turtle module is included with Python, then provides step‑by‑step code examples for drawing basic shapes like squares, stars, spirals, concentric circles, polygons, fractal trees, as well as advanced patterns such as colorful spirals, Koch snowflakes, Mandelbrot sets, the Chinese flag, and a simple map of China, all illustrated with complete runnable code snippets.
This article explains the technical differences between GDDR and HBM GPU memory, compares their bandwidth, cost, and use‑case scenarios, and helps engineers decide which memory type best fits their performance and efficiency requirements.
This tutorial shows how to use LaTeX's TikZ and related packages to create high‑quality function plots, statistical charts, and geometric figures that integrate seamlessly with document text, offering step‑by‑step code examples and visual results.
On the SM8650 platform, GLES issues synchronous and draw commands that the kernel‑mode driver translates into kgsl_drawobj structures, queues them in per‑context dispatch lists, processes fence, timestamp, and timeline syncpoints via dedicated kernel threads, and finally submits draw objects to the GPU firmware, with eglSwapBuffers triggering a fence syncpoint, a draw command, and a GPU fence creation.
This article demonstrates how to build a colorful, music‑synchronized fireworks animation in Python using the Pygame library, covering module imports, window setup, color definitions, the Fireworks class implementation, and the main loop that renders and animates the fireworks effect.
This tutorial introduces Python's built‑in Turtle graphics library, explaining how to configure the drawing canvas, use pen functions, draw shapes, apply fill colors, write text, and create animated balloon objects with movement and rendering loops for a festive visual program.
This article explains how to leverage WebGPU's compute pipeline and WGSL shaders to simulate the flocking behavior of tens of thousands of birds on the GPU, covering context creation, shader modules, pipeline setup, data buffers, and the rendering‑compute loop with full JavaScript code examples.
This tutorial walks through reproducing the Pepyaka shader effect using Three.js, covering the creation of a central sphere, vertex displacement with GLSL noise, color mapping, spherical particle systems, background firefly particles, animated text, and optional top‑light effects, all with complete source code.
This article walks through the mathematical analysis, coordinate calculations, and step‑by‑step Android code needed to draw an inverted equilateral triangle, animate a red/black tracing line, and rotate the shape with rounded corners, while addressing common pitfalls such as frame drops and aliasing.
This article introduces Python's Turtle graphics library, explains its educational and creative use cases, and provides five detailed code examples—including drawing a square, a colorful spiral, a flower, a heart, and a Fibonacci spiral—to help beginners learn programming concepts through visual output.
This tutorial demonstrates how to use Python and the Pygame library to create a real‑time visual simulation of the solar system, complete with background images, rotating planet sprites, optional music, and frame‑rate control, providing a hands‑on example of basic game‑style graphics programming.
This article provides a comprehensive technical overview of GPU architecture, from memory hierarchy and compute units to rendering pipelines and optimization techniques, explaining how modern graphics hardware processes shaders, manages resources, and balances performance across different rendering strategies.
This article walks through how to replicate Genshin Impact's login interface using three.js, custom GLSL shaders, instanced meshes, and post‑processing effects, providing detailed code snippets and explanations for background gradients, cloud layers, pillars, light beams, stars, fog, and rendering optimizations.
This tutorial demonstrates how to use Python's turtle graphics library to draw a festive mooncake for the Mid‑Autumn Festival, explaining common turtle parameters, providing a complete code example, and showing the resulting image.
This article explains why enhancing bloom (glow) effects is important for visual attention and scene aesthetics, outlines a generic WebGL implementation pipeline, discusses factors influencing bloom quality, and presents the Crystal WebGL engine's optimizations and performance comparisons between traditional and mipmap‑based approaches.
The article explains VSync’s origin, how it prevents screen tearing by synchronizing frame rendering with display refresh, and details Android’s implementation—including hardware and virtual VSync, Choreographer, Triple Buffer, key classes like VsyncTracker and VSyncDispatcher, and the offset/duration concepts introduced in Android S.
Mobile GPUs rely on tile‑based rendering to cut bandwidth and heat, and Vulkan’s thin drivers, explicit synchronization, and multi‑threaded command buffers let developers exploit this architecture—using proper load actions, subpasses, IDVS, and correctly placed barriers—to achieve notable performance boosts and substantial power savings on mobile devices.
This tutorial demonstrates how to use Python's pygame library to build a dynamic fireworks simulation, covering module imports, window setup, color configuration, class definition for fireworks particles, and the main loop that renders the animated display.
This article explains what a GPU is, compares its architecture to CPUs, explores its strengths in graphics rendering and AI inference, and outlines key specifications such as cores, cache, and memory, providing a clear overview for anyone curious about modern graphics processors.
This article introduces a live‑whiteboard demo built with OpenGL ES for iOS and Android, explains the implementation of multi‑channel rendering and multi‑texture approaches, compares their performance and flexibility, and provides complete GLSL and OpenGL code snippets for developers.
This article provides a comprehensive introduction to WebGL, covering its relationship with OpenGL ES, differences from Canvas and SVG, performance comparisons, step‑by‑step code examples for drawing points, squares and shaders, and explains the complete rendering pipeline for front‑end developers.
This article introduces Python's built‑in Turtle graphics library, explaining its drawing principles, import methods, and provides step‑by‑step code examples for creating shapes like triangles, stars, and hexagons, along with usage of color specifications and window configuration options.
This tutorial demonstrates how to build a classic "code rain" screen using Python's pygame library, guiding readers through imports, window setup, character rendering, and a concise main loop that produces the animated effect in roughly thirty lines of code.
This guide explains how to use the open‑source Skia 2D graphics library via the canvaskit‑wasm WebAssembly package to create surfaces, draw shapes, apply paints, shaders, blend modes, and perform 2D matrix transformations—including translation, scaling, rotation, skew, and perspective—culminating in a complete procedural design workflow with reusable JSX components.
This article details the four‑year development of SpriteJS, a high‑performance, cross‑platform graphics system that supports WebGL and Canvas2D rendering, DOM‑like APIs, responsive design, WebWorker integration, and extensive performance optimizations for visualisation and game applications.
The article surveys GPU rendering pipelines and hardware architectures for desktop and mobile, explains classic stages, compares Immediate Mode, Tile‑Based and Tile‑Based Deferred rendering, details PowerVR, Mali and Adreno components, and offers optimization advice on draw calls, depth pre‑passes, shader efficiency, and render ordering.
This guide explains why data visualization matters, how to create and save graphics in R, adjust graphical parameters, and use core plotting functions such as barplot, pie, hist, boxplot, and scatter plots to produce clear, informative charts.
This article explains how to represent, combine, and invert 2D and 3D transformations with matrices, demonstrates rotation around arbitrary axes, scaling in any direction, and provides JavaScript code for generating rotation matrices in WebGL contexts.
This article explains the visual persistence phenomenon, defines frames, frame rate (FPS) and refresh rate (Hz), describes screen tearing and vertical synchronization, compares movie and game frame rates, and relates these concepts to browser rendering and React's concurrent mode.
An end‑to‑end pipeline is presented that uses Blender to split and UV‑map a frame model, exports it as FBX, imports it into Unity where a runtime API dynamically updates materials, textures, colors and shininess for digital collectibles in the Taobao app, addressing mesh processing, FOV, lighting and anisotropic filtering issues.
This article guides beginners through the fundamentals of computer graphics, explaining OpenGL, WebGL, GLSL, and the rendering pipeline, then demonstrates practical Three.js code for setting up scenes, cameras, lights, materials, and textures to create interactive 3D web experiences.
This article examines the challenges of achieving view‑level background blur on Android, compares four implementation strategies—including open‑source libraries and custom AOSP modifications—analyzes their performance, compatibility, and visual quality, and provides code examples and practical recommendations for developers.
This guide introduces Python’s Turtle graphics library, explaining its screen and turtle concepts, and demonstrates how to draw rectangles, stars, circles, and arcs, while showing how to change pen attributes and apply fill colors, providing visual examples for beginners and intermediate learners.
This article demonstrates how to convert Cartesian coordinates to polar coordinates in GLSL, providing reusable shader functions and examples that generate a variety of intriguing shapes such as blades, clovers, buds, flowers, gourds, apples, and infinity symbols, while encouraging experimentation with parameters.
This article explains the concept of distance fields, shows how to compute distance fields for rectangles, lines, and line segments in GLSL, and demonstrates sampling techniques and curve rendering using WebGL shaders with complete code examples.
This article introduces WebGL fundamentals for frontend developers, explaining GPU versus CPU, GLSL shaders, and how JavaScript prepares data, followed by step‑by‑step code examples of fragment and vertex shaders, custom primitives, and using the gl‑renderer library to render graphics.
This article introduces WebGPU—a powerful yet still experimental web graphics API—showing how major frameworks like Three.js and Babylon.js adopt it for high‑performance 3D rendering, how TensorFlow.js leverages it for massive deep‑learning speedups, and provides hands‑on code examples from framework usage to raw WebGPU programming.
The article presents a Filament‑based PBR material editor that unifies PC and mobile workflows by providing real‑time ImGui previews, JSON‑driven persistence, model optimization, texture compression, and export/import of mobile‑ready material packages, thereby lowering authoring barriers, accelerating iteration, and ensuring visual consistency across platforms.
Version 0.7 of the open‑source Oasis Engine introduces a suite of enhancements—including a new text renderer, ClearCoat PBR material, dynamic PhysX colliders, expanded BlendShape support, HDR skybox loading, keyboard interaction, and API refinements—plus comprehensive documentation and example updates for developers.
Impeller, Flutter’s new rendering backend, eliminates runtime shader‑compilation jank by offline‑compiling GLSL to SPIR‑V and target APIs such as Metal, generating C++ bindings for fast pipeline state creation, offering predictable performance, portability and concurrency, though currently only the Metal backend is functional and feature support remains incomplete.
This talk explains how Ant Group's MarsStudio tackles the challenges of large‑scale marketing scenes by optimizing WebGL rendering to reduce CPU‑GPU communication and by using machine‑learning‑driven smart animation generation to let front‑end developers create dynamic effects quickly and efficiently.
This article introduces Python's turtle module, explains how to import it, configure the pen's speed, color, size, and use drawing functions such as forward, left, right, circle, dot, and goto, and provides several complete code examples for creating simple graphics.
This article demonstrates how to recreate the Three.js Journey floating 3D text effect using a React and Three.js stack, covering resource imports, DOM structure, state management, CSS grid background, font loading, geometry creation, mouse interaction, fullscreen handling, post‑processing effects, and responsive scaling.
This article explains how to leverage Android's custom Drawable to separate drawing logic from View interaction, demonstrates extracting reusable Drawable components for complex charts, and provides a complete Kotlin example that draws a basketball and animates it to the user's touch point.
This article explains how a graphics‑grammar‑based chart library called ChartSpace was ported to Flutter by recording Web canvas commands in a mock canvas, replaying them on Flutter's canvas, handling touch interaction conversion, and optimizing performance, while sharing the challenges and solutions encountered.
This tutorial walks you through recreating the 2022 Winter Olympics mascot Bing Dwen Dwen using HTML5 Canvas, covering the drawing of its body, ears, limbs, heart, logo, and facial features with ellipses, arcs, Bezier curves, gradients, and image rendering.
From early computer chess and arcade experiments to modern AI and virtual reality, games have continuously pushed hardware, software, and networking advances, inspiring breakthroughs such as UNIX, GPUs, game engines, and even medical research, proving that play is a powerful catalyst for technological progress.
This guide introduces Fabric.js—a library that adds an object model, SVG parsing, and interactivity to HTML5 Canvas—and walks through setting up a Vue project, installing the library, creating a canvas element, and drawing a red rectangle with concise code examples.
This article introduces the essential concepts and step‑by‑step implementation of 2D and 3D graphics rendering on the web, covering viewport transformation, triangle rasterization, anti‑aliasing, interpolation, camera setup, perspective projection, and depth testing using HTML5 Canvas and JavaScript.
This article introduces a Java-based 'Fu' character generator that randomly renders the Chinese 福 character with varying fonts and colors, explains the supporting FontUtil and ImgTool utility classes, provides the full source code, and demonstrates how to run and test the application using the space key.
In this translated AMA, Three.js creator Ricardo Cabello discusses his journey from the Demoscene to Google, the evolution of Three.js, challenges of open‑source maintenance, performance optimizations, WebGL versus WebGPU, VR/AR prospects, and the future role of web graphics in the metaverse.
This tutorial explains how to use Python's Pygame library to generate random-colored, expanding ripple circles that originate from mouse clicks, complete with code examples and visual screenshots of the resulting effect.
The article reviews the latest CSS Annual Report, highlighting popular layout techniques such as Flex, Grid and Subgrid, new graphic capabilities like shape‑outside and blend modes, interactive properties including scroll‑snap and container queries, as well as typography advances, preprocessors, frameworks, CSS‑in‑JS trends and award‑winning features, all illustrated with real code examples.
This short tutorial demonstrates how to use Python's turtle library to draw a red five‑pointed star by setting the fill color, looping five times, moving forward, and turning 144 degrees, with a complete code example and the resulting graphic.
The Quite OK Image Format (QOI) is an open‑source, lossless image format that promises PNG‑like file sizes with 20‑50× faster encoding and 3‑4× faster decoding, has a tiny C implementation, and has quickly attracted thousands of stars and community interest on GitHub.
This tutorial demonstrates how to use Python's Pygame library to create an interactive effect where clicking the mouse generates expanding concentric circles with random colors and sizes, stopping once a random maximum radius is reached, and includes the full source code.
This tutorial demonstrates how to use Python's turtle module to randomly generate and draw a starry sky, explaining the core logic of random positions, sizes, and angles for each star and providing complete code to render the night sky effect.
This article explains the Linux graphics display stack, covering FBDEV, DRM/KMS, V4L2, framebuffer memory layout, CRTC, plane, encoder/connector structures, ioctl registration, the component framework for device initialization, and how to use the libdrm‑provided modetest tool.
This article explores how various noise algorithms—including value, gradient, simplex, cellular, and FBM—are applied to short video visual effects, compares random number generators for GPU rendering, and provides GLSL code examples to illustrate implementation and performance trade‑offs.
This comprehensive guide walks you through Flutter's drawing fundamentals, covering Canvas, Paint, Path, Color, and advanced techniques such as custom text outlines, image shaders, and animated wave effects, with clear code examples and practical tips for creating dynamic graphics in mobile apps.
This article explains the mathematical foundations of fractals, demonstrates how to use Canvas coordinate transformations and vector operations, and provides complete JavaScript code for drawing classic fractals such as the Koch snowflake, hexagonal snowflake, and a binary tree using recursive algorithms.
This article explains the PHP imagefilledpolygon function, detailing its parameters, return values, and providing a complete example that creates an image, allocates colors, defines polygon points, draws a filled polygon, outputs the PNG, and cleans up the resources.
This guide explains the PHP GD function imagefilledellipse, detailing its parameters, return values, and a complete example that creates a blank image, fills the background, draws a white filled ellipse, and outputs the result as a PNG.
The article explains PHP's imagecreatefromxpm() function, detailing its syntax, parameters, return values, and provides a complete example showing how to load an XPM image, process it, save it as a JPEG, and clean up the resources.
This tutorial introduces Python's built‑in Turtle module, explaining how to draw basic shapes, control movement and rotation, set colors, use loops, define functions, handle events, and create simple animations, providing complete code examples for each concept.
imagecreatefromwbmp is a PHP function that loads a WBMP image from a given filename or URL, returning an image resource on success or FALSE on failure, with details on its parameter, return values, and a complete example demonstrating error handling and image output.
This tutorial demonstrates how to use Python's turtle module to programmatically draw a detailed Minion character by defining functions for each body part and assembling them with precise turtle commands.
This article introduces WebGL as a JavaScript API for 2D/3D graphics, outlines its history and basic concepts, demonstrates drawing a triangle with the native WebGL API, discusses its drawbacks, and shows how to create a rotating cube using the Three.js framework with complete code examples.
QuanTaichi introduces a new language abstraction and compiler system that quantizes simulation data, dramatically reducing memory and bandwidth usage so that high‑precision physical effects—once requiring multiple GPUs—can now run on a single GPU, even on mobile devices.
The PHP function imagecolorallocate() assigns a color to an image resource by specifying red, green, and blue components (0‑255 or hexadecimal), returns a color identifier or -1 on failure, and is demonstrated with example code showing how to set background, white, and black colors.
The PHP imagearc() function draws an elliptical arc on a GD image resource using specified center coordinates, width, height, start and end angles, and color, returning the transformed image on success or FALSE on failure, with a full example demonstrating its usage.
This tutorial introduces Python's turtle module, showing how to set up the canvas, control the drawing pen, and use a wide range of basic commands—including movement, drawing shapes, and screen management—to create graphics quickly and efficiently.
QuanTaichi, built on the Taichi language, introduces custom numeric types, bit‑struct adapters, and compiler optimizations that dramatically reduce memory and bandwidth for particle‑based physics simulations, enabling high‑precision GPU rendering on a single card and even on mobile devices.
This tutorial explains the fundamentals of YUV color space, its differences from RGB, and provides a complete WebGL workflow—including shader creation, texture mapping, and buffer handling—to convert YUV‑420p video frames into RGB images for browser rendering.
This comprehensive guide explains what SVG is, how it differs from bitmap images, its XML foundation, basic syntax, viewBox and viewport handling, common shape elements, animation, gradients, usage patterns, comparison with Canvas, optimization tips, fallback strategies, and media‑query integration, all illustrated with code examples and diagrams.
This article explains how short‑video apps render text on the GPU by converting characters into GPU‑friendly primitives, covering image‑based text, triangulated glyphs, vector rendering extensions, and signed distance field methods, along with their advantages, drawbacks, and practical libraries.
This article explains how to implement a dynamic video‑clip effect using Bezier‑curve‑based position, rotation, easing functions, and motion blur in a WebGL shader for Tencent’s Weijian mini‑program, detailing the mathematics, shader code, and practical steps to achieve smooth, natural animations.
This article explains the design and testing of a virtual‑classroom whiteboard feature, covering the socket‑based transmission protocol, data encoding, message structures, coordinate system, supporting Java classes (Point, BoardBase, BoardUser), shape‑drawing utilities, and a runnable demo that generates base64‑encoded MessagePack payloads.
The article analyzes how to update the positions of intermediate points on a wire when the user drags the wire with the mouse, compares three solution approaches—including point‑wise rotation and scaling, a complex geometric construction, and a unified transformation matrix—and summarizes their trade‑offs.
This article explains how Android's drawBitmapMesh method can be used to split a bitmap into a mesh, manipulate the vertex array to achieve various image‑warping effects such as face slimming, curtain folding and water‑ripple animations, and provides complete Java code examples and implementation steps.
This article demonstrates how to use PHP to generate a QR code, overlay it onto a background image, add custom text, and save the resulting composite image, providing complete source code and usage instructions for backend developers.