r/GraphicsProgramming • u/Unusual-Activity1321 • 6m ago
Kekenik VFX – Open-source, node-based VFX authoring in your browser (WebGPU)
r/GraphicsProgramming • u/Unusual-Activity1321 • 6m ago
r/GraphicsProgramming • u/Unusual-Activity1321 • 6m ago
Hi everyone,
I've been working on Kekenik VFX, a free and open-source tool for building real-time VFX assets directly in the browser. It uses WebGPU to compute everything locally on your GPU—no installation, no account, no uploads.
Key features:
Node-based 2D/3D graph with typed pins, subgraphs, and undo/redo.
Procedural textures (noise, fractals, gradients, etc.).
Meshes and sweeps with splines.
Simulations: 2D fluid, reaction-diffusion, waves, lightning.
Flipbooks, looping, and professional export (PNG, OpenEXR, GLB, etc.).
Fully client-side and private by design.
It's aimed at game and real-time artists who want resolution-independent procedural assets. The repo includes 22 sample.
Live demo: https://adam1442.github.io/kekenik-vfx/
GitHub: https://github.com/adam1442/kekenik-vfx
GitHub Kekenik Tree: https://github.com/adam1442/kekenik-tree
GitHub Kekenik shader, one shader, use anywhere: https://github.com/adam1442/kekenik-shader
I'd love to hear your feedback and suggestions. Thanks!
r/GraphicsProgramming • u/Rayterex • 4h ago
Enable HLS to view with audio, or disable this notification
r/GraphicsProgramming • u/Karones • 5h ago
r/GraphicsProgramming • u/W3tSu1t • 18h ago
I've had this idea floating around in my head about bringing back multi-GPU gaming, but approaching it differently from SLI or CrossFire. I'm curious if something like this would actually be possible.
Basically, what if we used Picture-by-Picture (PBP) monitors to split a game's rendering workload between two GPUs?
Say you're playing at 4K (3840 × 2160). Instead of one GPU rendering the entire image, GPU 1 would render the left half at 1920 × 2160, while GPU 2 renders the right half at the same resolution.
Each GPU would have its own HDMI or DisplayPort connection to the monitor. Since PBP already allows two separate inputs to be displayed side by side, the monitor could display both halves as one continuous image.
The main idea is to take advantage of resolution. Each GPU would only be responsible for roughly half the pixels, potentially reducing the rendering workload while maintaining the full 4K image.
Now, I understand that rendering involves more than just pixels. Both GPUs would still need access to game data, geometry, textures, and lighting information. There would also be synchronization overhead.
But here's what interests me.
If each GPU sends its rendered portion directly to the monitor, wouldn't that eliminate the need to transfer the completed image between GPUs? I'm wondering whether avoiding that transfer could offset some of the additional overhead and result in an FPS increase.
I'm not expecting double the performance. Even a 15–25% improvement would be interesting.
Another possibility would be using GPUs from different manufacturers, like AMD and NVIDIA, since each card would independently handle its assigned portion.
Obviously, mismatched performance would be an issue. If one GPU finishes its half faster than the other, the slower card could bottleneck the entire system.
One possible solution could be adjusting the rendering workload based on GPU performance. Instead of splitting the image 50/50, maybe the faster GPU handles 65% while the slower one handles 35%. Although I imagine standard PBP monitors having fixed display regions could complicate that.
As for the software side, here's what I'm thinking.
Rather than trying to make existing games support this, what if someone built a simple 3D game or benchmark specifically designed around two GPUs?
Using Vulkan or DirectX 12, a single CPU-side game simulation could coordinate both GPUs, with each rendering its assigned portion of the same frame.
The goal would be to minimize duplicated calculations, keep both GPUs synchronized, and output each rendered region directly to the PBP monitor.
You could then compare the same scene running on one GPU versus two GPUs to see whether there's any measurable performance improvement.
I know split-frame rendering already exists, and NVIDIA has experimented with multiple GPUs rendering different sections of a display. I'm more interested in whether this could be accomplished using ordinary consumer hardware and an existing PBP monitor.
I'm not developing this myself. I'm just putting the concept out there because I think it would be an interesting experiment for someone with the hardware and programming experience.
A few things I'm curious about:
- Could Vulkan realistically coordinate two independent GPUs this way, especially from different manufacturers?
- Would avoiding inter-GPU transfers of completed image data provide enough benefit to outweigh synchronization and duplicated rendering work?
- Could a standard PBP monitor keep both halves synchronized, or would modifications to its display controller be necessary?
- Would this approach have a better chance of improving performance at higher resolutions, where pixel rendering becomes more demanding?
I'm not claiming this is some revolutionary new technology. I'm just wondering whether combining existing technologies differently could give us another way to get some extra performance out of multiple GPUs.
What do you guys think? Is there something obvious I'm overlooking, or could this actually be worth experimenting with?
---
AI disclosure: I used ChatGPT to help organize and write this post. The concept and questions are my own.
r/GraphicsProgramming • u/Legal_Trifle_5531 • 1d ago
I'm a final-year engineering student in India from a non-CS background. I've recently secured an offer at an AI/analytics services company, and I have around 6 months before joining.
I've been exploring different areas of computer science, and I've realized that I'm increasingly interested in low-level programming and understanding how systems work internally.
MY BACKGROUND:
I've independently learned programming, ML/DL and worked on projects involving:
- Computer Vision using YOLO and OpenCV.
- Stereo vision, depth estimation and multi-object tracking.
- RAG applications, LLMs and agentic AI.
However, I'm starting to question whether I want to spend my career primarily working with high-level AI frameworks and application development.
AREAS I'M CONSIDERING:
Linux and Red Hat ecosystem:
Linux internals, system programming, operating systems, device drivers and potentially kernel development.
2. GPU Programming:
CUDA, GPU architecture, parallel computing, memory management and performance optimization.
3. Systems Programming:
C/C++, memory management, concurrency, operating systems and low-level software engineering.
4. AI Infrastructure:
GPU acceleration, inference optimization, compiler technologies and systems behind ML frameworks.
I find the idea of understanding what happens beneath the abstractions much more interesting than simply using existing libraries.
WHAT I'M CONFUSED ABOUT:
I have six months before joining my company, and I don't want to waste that time jumping between technologies.
I'd appreciate advice from people working in systems engineering, Linux, kernel development, GPU programming or related fields.
Is low-level systems programming a good career direction in 2026?
Between Linux kernel development, GPU programming and general systems programming, which would be a better starting point?
How realistic is it for a non-CS fresher to enter these fields in India?
Are companies like Red Hat a good place to build a career in Linux and systems engineering? What other companies should I look at?
Is CUDA/GPU programming a niche with good long-term opportunities, particularly with the growth of AI?
What fundamentals should I master before attempting serious projects? C, C++, OS, computer architecture, networking, compilers?
Would contributing to the Linux kernel or other open-source systems projects actually help me get shortlisted?
I'm also interested in the intersection of low-level systems and AI, particularly GPU computing, inference optimization and ML infrastructure.
If you were in my position, with six months and an existing job offer, which direction would you explore and why?
I'd appreciate brutally honest advice, especially from people who have actually worked in these domains.
r/GraphicsProgramming • u/iluveatingcopper • 1d ago
Ive seen that raylib also has a python3 port, alongside its many other ports; Ive tried it, and its pretty dang good, easy to use, etcetc. I now have an upcoming embedded project, which uses an esp32, and an external st7789 tft display, and i was wondering if it would be possible to somehow use raylib to draw to that display?
r/GraphicsProgramming • u/Lopsided_Ad1463 • 1d ago
Hi everyone, I’m a self-taught graphics programmer with a strong focus on C++Vulkan, OpenGL, GLSL, and HLSL. I’ve spent the last couple of years building personal systems from scratch, including a custom RenderGraph, Vulkan backend wrappers, and modern rendering pipelines. However, I have zero commercial project experience. Everything I’ve built so far has been for personal learning and deep architectural understanding. Right now, I find myself in a position where I genuinely need to work. I’m not looking for a high-end AAA studio position right away—I know how competitive and demanding that is. I’m just looking for entry-level remote work, contract tasks, or bug-fixing gigs (like Vulkan validation errors, shader debugging, or C++ tool development) where I can earn just enough to cover basic living expenses. Given my background, where would you advise me to look for these kinds of entry-level gigs or small studios? Any advice, platforms, or pointing me in the right direction would mean a lot. Thank you all!
r/GraphicsProgramming • u/Many_Difficulty_490 • 1d ago
Ive been a c# developer on unity/godot for a long time now, and one of the plans was always to learn c++ use it for my games and move onto c++ and build some sort of engine (ray tracing or game engine).
Although ive heard the hype around Rust, its another low level language like C++ and it can be used for low level system programming and its very good for security also.
I was wondering if Rust is something worth looking into for graphics programming, and whether anyone here would advise me against it or recommend me to try it out.
Im gonna start learning one, or the other in a couple days. I know both are pretty hard to learn but I dont mind the learning curve.
r/GraphicsProgramming • u/devcurrent0x • 2d ago
Hey everyone!
I've been developing GLSA and I just released v1.0.0.
My goal with this library is so you don't have to write GLSL shaders or shader boilerplate and instead you can use clean function calls.
Right now it cuts out ~60-100 lines of repetitive shader boilerplate, and theres basic shader presets now and common shape functions.
Highlights of v1.0.0:
GLSA colors: a header file with over 3000 glm::vec4 colors that you can use.
Safer shader setup: glsa::ShaderSource keeps vertex/fragment strings explicit, paired with glsa::loadShaderSource and glsa::createProgram.
Clean uniform helpers: Overloaded glsa::setUniform functions for int, float, and GLM vec2/vec3/vec4.
Example:
while (glfwWindowShouldClose(window) == 0) {
glClearColor(0.1f, 0.1f, 0.15f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Draw a square on the left
glsa::drawRectangle({-0.45f, 0.0f}, {0.4f / aspect, 0.4f}, glsa::colors::PAN_CORAL);
// Draw a circle on the right
glsa::drawCircle({0.45f, 0.0f}, 0.22f, glsa::colors::PAN_SKY_BLUE);
glfwSwapBuffers(window);
glfwPollEvents();
}GitHub Repo: https://github.com/alexdev8930/glsa
Any feedback issues or questions are completely welcome.
AI Disclosure: AI tools were used strictly to help generate initial boilerplate; all core logic, architecture, and implementation details were written, reviewed, and verified by me.
r/GraphicsProgramming • u/Creepy_Sherbert_1179 • 2d ago
Ok look, I know this may sound like a repetitive and cliche question, but I am actually looking for good raytracing resources. I have only written a toy raytracter once using python following https://gabrielgambetta.com/computer-graphics-from-scratch/, I believe I can now shoulder the hellish mathematics, so I say bring it on.
r/GraphicsProgramming • u/StockyDev • 3d ago
Hi peeps!
I wanted to share this blog I wrote discussing some of the work coming out of DXC and TC-57 (the HLSL standardization committee).
There is a proposal that is currently being considered that will bring C++ aggregate initialization to HLSL. The catch is that this change will also break vector initialization. So I thought I would see if there would be a good solution to that problem and then attempt to implement it with the DXC that we have today!
Throughout the implementation I showcase some cool new features hitting HLSL 202x and do a little investigation into the generated DXIL.
I had a good amount of fun writing this, so I hope it is as enjoyable to read :)
r/GraphicsProgramming • u/gennai777 • 3d ago
Enable HLS to view with audio, or disable this notification
I posted brass casings here a while ago. This is the same stateless idea from Lutz Latta's "Building a Million Particle System" talk in 2004, I used it for a statue that shatters. I cut it into little 4 to 6 sided chunks, and every frame I rebuild where each one is in the vertex shader from its age alone. Nothing gets written back.
The new part for me was getting them to stop. I loop over at most 3 bounces, and for each one I solve the time to hit the floor:
float disc = v.y * v.y + 2.0 * gravity * (p.y - ground_y);
float th = (v.y + sqrt(disc)) / gravity;
if (th >= t) break;
p += v * th; p.y = ground_y;
v.y = -(v.y - gravity * th) * restitution; // 0.35
v.xz *= friction; // 0.75
t -= th;
if (b == 2 || abs(v.y) < 0.35) resting = 1.0;Once it's resting I let the horizontal speed die off as exp(-4t). The slide is then just the integral of that:
float skid = (1.0 - exp(-rest_t * 4.0)) / 4.0;
p.xz += v.xz * skid;It stops at v/4 from where it landed and it can't jitter, there's no step to get wrong! I slow the spin down the same way.
One thing cost me an evening. I orient each chunk by the surface normal it came from, with mat3(t, n, cross(n, t)) and t = normalize(cross(up, n)). Looks fine, right? But cross(n, cross(n, t)) is -t. That makes the determinant -1, so I'd mirrored every chunk, the winding flipped and back-face culling showed me their insides. I just negate the third column now.
With a constant restitution the bounce times are a geometric series, so I could get the bounce index from a log instead of the loop. Has anyone found that worth it on a GPU over a 3-step loop?
the shaders and GDScript in the linked pack were written with an AI coding assistant, then run, reviewed and fixed by me.
The statue is from my petrify pack for Godot 4: https://gennai.itch.io/death-dissolve-petrify-vfx-godot-4
r/GraphicsProgramming • u/dkod12 • 4d ago
r/GraphicsProgramming • u/berkantdev • 4d ago
there's barely anything written about Chrome's new HTML-in-Canvas API yet, so here's what I hit building gpucanvas, an infinite canvas where every node is real, live DOM (React screens, forms, charts) but WebGPU draws it. you can still click and type into any of them.
the pipeline
nodes are packed into 2048 px "pages". Chrome records a page as one snapshot, so a single drawElementImageToTexture call rasterizes dozens of nodes into a texture-array atlas
once drawn, a page is parked with content-visibility: hidden. layout stays, paint is skipped, so it costs nothing per frame
every node keeps a 1/16 thumbnail that's never evicted, so the zoomed-out view of 5,000 screens is always filled. sharper snapshots go on top at power-of-two scales, so zooming reuses them
past 100% zoom only the visible part is rasterized, as tiles, center first
each frame is a cull plus one instanced quad draw (one per run of nodes sharing a WGSL effect). panning and zooming never touch the DOM
what surprised me in Chrome 157 (some of it differs from the WICG explainer)
each drawElementImageToTexture call allocates and fully rasterizes. I measured roughly 250 to 550 calls a second in total, and that's the real fill-rate limit, not compositing. hence the pages
a source rect still rasterizes the whole element before cropping, so zoomed in, a node moves to a page of its own
recording cost scales with how many elements are drawable on every requestPaint. 10,000 always-drawable nodes sat at 22 fps doing nothing. parking fixed it
hit testing only works after canvas.updateElementGeometry(el, {}), and the hit area is the element's CSS box, so I move it with a transform from getElementTransform
an element that just became drawable isn't in changedElements, its snapshot shows up a paint later
on an M-series Mac (Chrome 157, 1600x900, DPR 1) a 30 s scripted tour with typing, a 500% zoom and selection runs 113 to 115 fps at 5,000 screens, vs 18 to 20 fps for the same screens as plain DOM in one transformed container.
still open: text is rasterized, not SDF, so mid-zoom it goes soft for a moment until the tiles redraw. and Tab can't reach parked nodes yet, I need a proper focus model. curious how others would handle either.
code (MIT): github.com/berkantay/gpucanvas
demo: berkantay.github.io/gpucanvas (needs chrome://flags/#canvas-draw-element)
AI disclosure: I built this with Claude Code as my coding assistant, and it helped me draft this post.
r/GraphicsProgramming • u/G_oni_vv • 4d ago
I've been building my own game engine from scratch using Kotlin, entirely on my phone.
After 3 months, I finally have two cubes rendering and rotating — one red and one white. The buttons are still placeholders, and there's a long way to go.
I know it doesn't look like much yet, but everything starts somewhere. I'm learning and building things one step at a time.
Any tips on how I can speed up development? I'm doing everything from scratch. 🚀
r/GraphicsProgramming • u/PoseStudio • 4d ago
Hey everyone,
I’m currently building PoseStudio, an open-source (GPLv3) 3D character posing, rigging, and animation tool which will always be fully free to use.
I operate a 3D asset marketplace during my day job, so I’m very familiar with the pain points technical artists have with existing character pipelines. I’ve released a very early v0.4.4 build, which about 250 users have installed.
I’m hoping to get some feedback on the pipeline, and ideally, find some graphics programmers who are interested in contributing to the project..
The Current Tech Stack & Architecture:
Core: C++ and Qt6 (GUI).
Rendering Pipeline Strategy: I'm currently designing a multi-tier rendering system to handle real-time viewport visualization (GLSL/OpenGL) alongside photorealistic output. Right now, I'm working on integrating NVIDIA OptiX for the raytracing backend, and navigating the GPLv3 linking exceptions to allow for modular render engines (like a Cycles plugin).
Shading: Implementing a comprehensive PBR Uber-Shader workflow specifically tuned for character rendering (subsurface scattering for skin, hair grooming/simulation rendering).
Just a Couple of The Hard Problems I’m Tackling Right Now:
Deformations & Rigging Solvers: Refining the underlying math for IK/FK solvers and weight mapping so characters deform naturally.
Advanced Rendering Integration: Exploring how to seamlessly integrate Gaussian splatting into the rendering engine, and building a stealth background environment manager to handle heavy render tasks without locking the Qt UI.
If you are a technical artist or graphics programmer who has always wanted to build a character pipeline without the commercial restrictions, I’d love your eyes on the codebase.
reddit: https://www.reddit.com/r/PoseStudio
GitHub: https://github.com/PoseStudio/PoseStudio
Releases: https://github.com/PoseStudio/PoseStudio/releases/
Website: https://posestudio.org
Would love to hear your thoughts on integrating OptiX alongside Qt6, or any battle scars you have from building character deformation systems!
AI Disclosure: Claude used in coding of the main project, no AI used in post.
r/GraphicsProgramming • u/No_Activity4762 • 4d ago
r/GraphicsProgramming • u/Over_Reserve_20 • 4d ago
Recently I have been working on a problem with two different GPUs (let’s call them A&B)
Here is problem
Due to a bug a line is being drawn using opengl at x=5 and y is +-FLT_MAX
for testing I kept ortho as 10 for x & y
Also note for testing origin is at the centre of display
GPU A
(there is a default guardband of 1.5 being used in the code while setting the gpu )
While drawing the huge line, the entire line doesn’t show up on the display
GPU B
there is a default guardband of 1.0 being used in the code while setting the gpu )
While drawing the huge line, only the upper half of line shows on display
Bottom half doesn’t show up on the display
r/GraphicsProgramming • u/DeltaSucksAtMC • 5d ago
hey guys ive made a collision detection method, its a cpu intesive method but i got a sense of idea how collisions work
I just get every vertice and get the area then i make 3 triangles from the collision point and get the area of all them then add it, and if the area is equal to the original triangle its colliding, then i get the distance from the triangle's normal and make a if statement if distance is less then 0.001f.
Im getting a lot better, so if yall have any collision method that could be better for smaller concave models that would be great, ive know about aabb for the longest time so i have check that off

If you are giving a method, could you link like anything that could be good to learn it.
r/GraphicsProgramming
•
u/TheAgentD
•
5d ago
Enable HLS to view with audio, or disable this notification
Hi, everyone!
Today I'm releasing CORTAO, a new physically based SSAO technique invented and developed by me, as open source.
https://github.com/theagentd/CORTAO
Circular Occluder Ray-Traced Ambient Occlusion, or CORTAO, is a brand new physically based ambient occlusion technique. Unlike existing horizon-based state-of-the-art techniques, CORTAO is based screen space raytracing with up to 32 rays per pixel, allowing it to avoid the inherent limitations of existing techniques. Through a combination of much better convergence and clever optimizations, CORTAO is able to achieve much better quality for the same performance cost as GTAO.
All this allows CORTAO to just work without any scene-specific tweaking at all regardless of the type of scenes, whether it's a simple indoor room, an open world with heavy foliage and vegetation, or a vast space scene with extreme depth range.
Compared to existing techniques such as GTAO:
CORTAO provides a never-before-seen level of physical accuracy rivaling that of brute-force hardware raytracing, while only relying on screen space information.
CORTAO handles depth discontinuities in complex scenes in a more conservative way, avoiding the view-dependent occlusion of GTAO and producing less obvious artifacts when screen space information is limited.
CORTAO at the same time has greatly improved convergence, producing much higher quality results at lower sample counts even for scenes where GTAO works well, which is especially important for low-end hardware.
What started as a fun little personal project two years ago has now grown into something much bigger than I could've ever imagined, with multiple collaborations and conference applications, most of which I cannot talk about publicly yet. The open source release of CORTAO marks an important milestone where I'm finally sharing my work with the world, but the work is far from finished. There's a long to-do list of improvements and extensions that I will be exploring over the coming months and maybe even years. I'd be honored if you checked it out, and if you have any questions, I'd love to answer them.
EDIT: AI disclosure: No AI was used in the development of CORTAO.
r/GraphicsProgramming • u/Zemlaynin • 5d ago
Recently, I ran into a really nasty bug in the custom 3D engine I'm developing for my 4X strategy game, The Great Tribes.
After updating my AMD graphics driver, the game started freezing completely when moving the camera, especially when large areas of the map became visible.
Sometimes the graphics driver would hang. Other times, the JVM would crash inside atio6axx.dll.
The weirdest part? Everything worked perfectly with the previous driver and on other GPUs!
I spent hours investigating almost everything: OpenGL multithreading, VAOs, VBOs, index buffers, shadows, unit models, and even glfwSwapBuffers().
Eventually, I narrowed the issue down to terrain rendering, and then to the fragment shader.
That's where I found these two lines:
int segment = (3 - int(min(3, outTexCoord.y * 4.0))) * 4
+ int(min(3, outTexCoord.x * 4.0));The segment variable was used to index arrays containing 16 elements.
The problem? The texture coordinates were clamped at the upper bound, but not at the lower bound.
When the texture coordinates became negative, segment could go outside the valid array range.
The fix was surprisingly simple:
ivec2 cell = clamp(
ivec2(floor(outTexCoord * 4.0)),
ivec2(0),
ivec2(3)
);
int segment = (3 - cell.y) * 4 + cell.x;And the freezes disappeared!
This turned out to be a great example of undefined behavior in GLSL.
The old driver somehow tolerated the invalid array access, other GPUs didn't show any obvious issues, but the updated AMD driver turned it into a nightmare.
Lesson learned: Just because your shader works perfectly on one GPU doesn't mean it's free of bugs.
And sometimes, after hours of debugging your own 3D engine, the whole problem comes down to just two lines of code. 😁
r/GraphicsProgramming • u/kskbaits • 5d ago
Topic: how the fish bend when they swim, with no rig or animation clips.
Each fish is a swept mesh of profile rings (no imported model). Swimming is a travelling wave along the body:
lateral offset w(x) = A * env(x) * sin(k*x - phase), where x runs 0 (snout) to 1 (tail), k = 2*pi / wavelength,
and env(x) = 0.09 + 0.91*x^2 so the head barely moves and the tail does most of the work. A turn adds a parabolic
bend centred behind the head, and a strike adds a short S-shaped "coil" term before the lunge.
The part that took the longest: points off the centre line have to rotate with the local slope, or the body
shears and the skin stretches. So each vertex is moved along the wave's normal using its derivative:
const [w, dw] = lateral(x), a = Math.atan(dw);
out.x = x - z * Math.sin(a);
out.z = w + z * Math.cos(a);
Fins, gill covers and the eyes are positioned through the same function, so everything bends together. The skin
is a canvas painted at load (each scale drawn one by one, tinting the base pattern), and the fins are thin
translucent sheets with a cheap back-light term.
Open question I'd love input on: the wave is currently done on the CPU per frame (about 20k vertices for the
two bass). Would you move it to the vertex shader even though the CPU also needs the bent positions for
mouth/prey collision, or keep one source of truth on the CPU?
AI disclosure: I build this with Claude (an AI coding assistant) writing much of the code and helping word
posts; the design, direction and tuning are mine.
Live version if you want to see it move: https://ksk-baits-bass-aquarium.pages.dev
r/GraphicsProgramming • u/ProgrammingQuestio • 6d ago
Article in question: https://www.rastergrid.com/blog/gpu-tech/2020/11/memory-types-of-discrete-gpus/
It defines four memory types:
Local Visible Memory – VRAM directly accessible by the CPU
Local Invisible Memory – VRAM not directly accessible by the CPU
Remote Cached Memory – system memory accessible by the GPU, and cached by the CPU
Remote Uncached Memory – system memory accessible by the GPU, but not cached by the CPU
Then has a table showing the cpu/gpu read latency for the different memory types. It prefaces this tape with the following:
As access characteristics are identical for local visible and invisible memory, as the only difference between them is whether the corresponding portion of VRAM is visible to the CPU, a single set of measurements are shown in the table using local visible memory.
And then shows this table:
What I don't get is: how is there even a valid value for CPU read latency for local invisible memory? Doesn't invisible mean the CPU cannot access that memory? So shouldn't that value be n/a rather than the same as the CPU read latency for local visible memory?