r/computergraphics

Hey everyone. I've been working on a web-based Gaussian Splatting viewer for the last few months and wanted to share some findings.

Make a viewer that works on any device, including budget phones, without plugins or native apps.

- SparkJS 2.0 for rendering
- Progressive streaming via chunked RAD files
- HTTP Range requests from Cloudflare R2
- Adaptive quality system that detects GPU capabilities in real-time

Real-world results (tested on actual devices):

Scene	Desktop (RTX 3070)	Xiaomi 15 Ultra	Redmi Note 11 (€200)
Tufia (8.5M splats)	60 fps	55 fps	40 fps
XGrids Demo (12M)	60 fps	45 fps	30 fps
50M splats	60 fps	25 fps	15 fps
100M splats	55 fps	15 fps	8 fps

What I got wrong:

1. Optimized too early. Spent weeks on custom compression before realizing `build-lod --rad-chunked --max-sh=3` already hit the sweet spot. The tooling is better than I expected.

2. Ignored the data problem. Users were uploading raw 500MB PLY files and wondering why nothing loaded. Had to build the conversion step into the workflow.

3. Assumed all phones are equal. They're wildly different. The adaptive quality system exists because of this mistake.

What I learned:

- Streaming > monolithic files. Progressive loading changes the UX entirely.
- `--max-sh=3` is the sweet spot for mobile. Higher SH bands have diminishing returns on small screens.
- The web is underrated as a platform for this. More people can click a link than download an app.

Happy to answer questions about the technical details. Live demo:
https://mirador3d.com/v/penthouse-demo

more in my Instagram <3

my initial implementation of flame fractal rendering , which was calculated , shaded , post processed and saved as jpeg by new version of my 4kfract program :

try from : https://www.deviantart.com/pgmatg/art/1334677136

Archive containing the application is in the premium download. After extracting content of beta version of into separate folder, then can try serialization of chaos flame fractal by starting 4kfractFlam.bat. You can run 4kfract3d.bat script to generate sample opengl 3d view of set of randomly iterated fractal projections, it also saves more detailed flat and iso versions of those fractals as jpg files in that folder.

Can also run 4kfractui.bat to use web browser based ui cgi form to utilize most of capabilities of the application to create fractal images using preset or custom complex number formula. Most settings are explained on the page. For cgi form to remember advanced detailed settings uncheck quick mode box up top

Hi all,

Does anyone happen to know the specific technical concept he's describing here? (Source: https://www.nintendo.com/en-za/Iwata-Asks/Iwata-Asks-The-Legend-of-Zelda-The-Wind-Waker-HD/The-Legend-of-Zelda-The-Wind-Waker-HD/5-Over-designed/5-Over-designed-807330.html )

I have noticed that Wind Waker HD has much brighter brights and darker darks than its GameCube predecessor. I've also noticed that this is the case generally when it comes to 8th gen games compared to 6th gen ones.

But I was wondering, specifically what is the reason for this? It's not true that the GameCube couldn't display anything that bright or that dark, right? So why couldn't you have that high contrast look you see in newer games? Like why do say ps2 games look so flat and washed out compared to a lot of ps4 ones in terms of tonal contrast?

FPT v1.22 : https://github.com/adam-pa/FPT/releases/tag/v1.22
Github : https://github.com/adam-pa/FPT

Hey guys! I'm so happy to release FPT v1.22, I've improved the SDF editor UI, added built in fractal library and much more!

For those who don't know, FPT is a sdf path tracer mainly built for rendering fractals.

An experimental temporal ghosting / long-exposure toolkit for TouchDesigner, built for turning prerecorded and real-time footage into smeared, split-exposure, echo-like motion.

The system layers delayed frames, masks the active subject region, and adds optional feedback persistence to generate distorted portrait, face, and full-body trails that sit somewhere between long exposure, temporal rupture, and spectral motion blur.

This release also includes:

— a custom FLUX-2 LoRA trained on experimental photography [the one used in this demonstration]
— the pertinent ComfyUI workflow for FLUX-2.dev + LoRA text-to-image generation

Available now through my Tools Store.

Both music and visuals by myself, deeply inspired by the recent BoC-related events.

Hey Everyone,

I m the creator of the above project null-graph. Although there is no relation to the threejs.I still wanted to post here,Cause creation of this project came from the motivation of threejs failing me at big level sorta,What I wanted to ,I just wasn't able to do without digging deep into custom logic territory.Hence the creation of the library null-graph

It's not a competitor to threejs and other similar since it follows entirely different philosophy and has steeper learning curve,but would help enable all the most advanced techniques that are used by native game engines or renderer cleanly.

At its current state it has

1.GLBParser

2.Animator and SkeletonManagers

3.A StandardPBRMaterial(based of cook torrance)

4.all lights have been hard-coded for now

5.Multi pass and multi batching along with ability to create some primitive shapes

Live:https://null-graph.web.app

I have added docs and a hello world tutorial to Render your first shape.Feel free to do AMA,or roast out,give honest feedback.I have put my heart and soul in the project

Created by my 4kfract program . most recent version included in premium download : https://www.deviantart.com/pgmatg/art/Fractal-split-dimension-flower-bed-Iso-1333642959

a custom software renderer that I'm currently working on inspired by old school games and graphics going for that 90s digital painting look

Apologies in advance for low res

This will be for a informational video for YouTube, so VO will be put over it.

Approximate convex decomposition is widely used for physics simulation / collision geometry, but existing methods are often slow, unstable, or produce lots of tiny convex pieces.

We built a GPU-accelerated approach based on a visibility-derived concavity metric that avoids repeated convex hull computations and directly optimizes cutting planes on the GPU (CUDA + OptiX).

Some properties we were pretty happy with:

• rotation-equivariant
• intersection-free decompositions
• significantly faster than prior work
• usually fewer convex parts for similar or better quality

A lot of the work went into making the optimization robust while keeping everything massively parallel.

Would love to hear thoughts / feedback from people working in geometry processing, simulation, or game physics.

Project page: https://3dlg-hcvc.github.io/visacd/

Hey all,

In light of my recent post on my Golang path tracer, I realized that I never really looked for any feedback for my other graphics project: a software rasterizer in C:

I lost motivation after some time developing it, but I got it to a place where it can render basic OBJs with interpolated vertex normals for colour, and some debug views for viewing wireframe and vertex normal directions.

I think a large part of my stopping the project is because the performance felt hopeless. Even for simple models with backface culling and clipping, the FPS drops when a large part of the screen is "taken up" by the models.

And then there's the architecture: I don't really know how to approach it. My `engine.c` file kind of represented most of the logic, but it feels messy.

Would love if you checked it out and gave any feedback!

Link: https://github.com/SeanJxie/impromptu

Started with polylines. Accidentally built wave simulation. Ended up with ducks 🦆
Everything runs on CPU. No compute shaders, no tricks. Just geometry, math, and bad decisions.

#openglobus #javascript #webgl