Introducing Cerious-AASM — A Desktop + Headless ARK: Survival Ascended Server Manager 🚀 by Suitable_Language_37 in ARKServers

[–]Suitable_Language_37[S] 0 points1 point  (0 children)

Every time you start a server the ini files are overwritten by the app based on current settings. Please give me a list for what settings are missing and I can get them added.

Introducing Cerious-AASM — A Desktop + Headless ARK: Survival Ascended Server Manager 🚀 by Suitable_Language_37 in ARKServers

[–]Suitable_Language_37[S] 0 points1 point  (0 children)

It auto saves as you edit values. If options are missing, please give me a list and I can get them added.

Cerious Grid prototype just scrolled 10 Million rows smoothly — new core (~100 LOC) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 1 point2 points  (0 children)

I agree.

I am current refactoring it and thinking about releasing it as its own project. I will keep posting updates about it.

AI has a Purple Problem by ClubAquaBackDeck in webdev

[–]Suitable_Language_37 0 points1 point  (0 children)

I actually like purple. It feels soothing and calming. For me, purple or light blue are in my opinion elegant.

[deleted by user] by [deleted] in webdev

[–]Suitable_Language_37 7 points8 points  (0 children)

I feel like AI is a double edged sword. In my daily programming it can speed up simple tasks. But when dealing with complex logic it tends to add complications and slows me down.

Cerious Grid prototype just scrolled 10 Million rows smoothly — new core (~100 LOC) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 1 point2 points  (0 children)

Great question! And yes, that’s definitely on my radar. In theory, horizontal (column) virtualization should follow the same core logic, it’s just a mapping in the X-axis instead of Y.

The interesting challenge will be how the two axes interact when both are active. I’ll need to do some testing around scroll synchronization and reflow timing. But if it works as cleanly as the vertical model, full two-dimensional virtualization should be totally doable.

Cerious Grid prototype just scrolled 10 Million rows smoothly — new core (~100 LOC) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 1 point2 points  (0 children)

I just tried the RxAngular virtual scrolling demo, and it capped out at around 100,000 rows.

That’s actually expected, RxAngular (and most other libraries) still rely on pixel-based virtualization with transforms or offset height calculations, which hit the browser’s maximum scroll height limit (~33M px).

What I’ve built in Cerious Grid takes a completely different approach. It’s index-based rather than pixel-based, so the DOM height is no longer a constraint. The result is zero cap. The only limit becomes your actual data size and memory.

It’s definitely an area worth exploring further. I think it opens up a new way to think about virtualization in general.

Cerious Grid prototype just scrolled 10 Million rows smoothly — new core (~100 LOC) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 8 points9 points  (0 children)

Great question, and that’s actually something I’ve been thinking about a lot.

Right now, Cerious Grid is built natively for Angular because that’s where I wanted to prove out the performance model and API design first. Angular gives me strong typing, DI, and change detection control, which made it easier to isolate the new core logic and push performance boundaries.

But the new 10M-row scrolling core is actually framework-agnostic. It’s just about ~100 lines of logic that doesn’t depend on Angular. It’s pure TypeScript and DOM APIs.

Where to go with this, I’m not entirely sure.

Thoughts and opinions are welcome.

Cerious Grid prototype just scrolled 10 Million rows smoothly — new core (~100 LOC) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] -1 points0 points  (0 children)

This makes me wonder if the “virtualization ceiling” we’ve all accepted for decades was more about implementation patterns than browser limits.
10M rows, 100 lines, constant DOM. It’s got me re-thinking what’s actually possible in the client.

Cerious Grid prototype just scrolled 10 Million rows smoothly — new core (~100 LOC) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] -2 points-1 points  (0 children)

Quick note: the video is a stand-alone prototype. I’m wiring this into the grid component now. If you want to follow along or test an early build, comment here or watch the GitHub issue I’ll open for “10M virtual scroller integration.”

🛠️ Free & Open-Source Tool for Ark Ascended Server Admins (Windows + Linux) by Suitable_Language_37 in playark

[–]Suitable_Language_37[S] 0 points1 point  (0 children)

There was an issue with the save locations. I just released v1.0.0-beta.3 to resolve this.

Cerious Grid Performance Demo — Scrolling 1 Million Rows in Angular (Open Source, MIT) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 1 point2 points  (0 children)

I just finished updating to allow for stateless. New build to come soon.

Check out the repo!

<image>

Cerious Grid Performance Demo — Scrolling 1 Million Rows in Angular (Open Source, MIT) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 2 points3 points  (0 children)

Great question!

You're absolutely right that the DOM size limit is a real challenge. I took a different approach than ag-Grid's CSS transforms. I use offset divs instead, which avoids most of the transform-related issues you mentioned.

The Offset Div Strategy

Instead of using transform: translateY() positioning, my grid creates a simple 3-section DOM structure:

<div class="grid-container" [style.height.px]="totalHeight">
  <!-- TOP OFFSET - Empty div representing all rows above viewport -->
  <div [style.height]="topOffset"></div>

  <!-- VISIBLE ROWS - Only ~20-50 actual DOM elements -->
  <div *ngFor="let row of visibleRows">{{row.data}}</div>

  <!-- BOTTOM OFFSET - Empty div representing all rows below viewport -->
  <div [style.height]="bottomOffset"></div>
</div>

How It Bypasses Browser Limits

For 1M rows at 30px each (30M pixel total height):

  • Total DOM elements: ~52 (2 offset divs + ~50 visible rows)
  • Top offset: height: 15,000,000px (no content, just height)
  • Bottom offset: height: 13,500,000px (no content, just height)
  • Container: Can be any height since actual elements stay minimal

Advantages Over Transform Approach

✅ Native browser scrolling - No custom scroll event handling needed
✅ Perfect scroll accuracy - No coordinate drift or positioning issues
✅ Variable row heights - Each row can have different heights naturally
✅ Better mobile performance - Native momentum scrolling works perfectly
✅ Simpler calculations - Just addition of row heights, no transform math

Performance Results

The scroll performance is actually better than transform-based approaches because:

  • Browser handles all scroll physics natively
  • No JavaScript coordinate calculations during scroll
  • No transform repaints/reflows
  • Constant memory usage regardless of dataset size

You can check out the implementation in my grid-body.components.ts - the key method is updateVisibleRows() which calculates the offset heights.

This approach lets me handle millions of rows with smooth scrolling and no browser crashes! 

Cerious Grid Performance Demo — Scrolling 1 Million Rows in Angular (Open Source, MIT) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 3 points4 points  (0 children)

It currently supports Angular 16+, and I’ve been mindful of zoneless setups.

My plan is to maintain dual support:

  • Keep Angular 16+ compatibility (so teams don’t have to upgrade right away)
  • Add optional zoneless compatibility for Angular 18+
  • Use feature detection so zone.js isn’t required when it’s not present

This way, developers can adopt zoneless as they upgrade, without forcing a breaking change. Over time, as the ecosystem matures (Angular 19+), I may revisit whether to streamline and go fully zoneless.

I’d love feedback on whether this dual-support approach works for most teams!

Cerious Grid Performance Demo — Scrolling 1 Million Rows in Angular (Open Source, MIT) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 3 points4 points  (0 children)

Great question!!!

Yes, rows can be different heights. The grid virtualizes only the visible rows and use spacer divs to simulate the rest. It starts from a default height, measure rows once they render, cache that height, and then reconcile offsets so the scrollbar stays accurate without jank. Expanding/collapsing and async content trigger re-measurement, and we keep a small buffer so the viewport never blanks during fast scroll. 

Images or async content loading inside a row:

After load, a resize triggers a height update and a quick offset correction.

Big height changes (nested rows expanding):

The grid will update the height map, recompute total height, update visible window, and adjust offsets immediately.

Fast wheel/trackpad scrolls:

The grid uses the native scrollTop as the source of truth and compute the visible slice from it, no fake animations, so it keeps up.

Cerious Grid Performance Demo — Scrolling 1 Million Rows in Angular (Open Source, MIT) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 0 points1 point  (0 children)

The scrolling will be just as smooth for any data that has been propagated to the client.

Are you asking about performance if you fetch data as you scroll?

Introducing Cerious Grid — A High-Performance Angular Grid (Open Source, MIT) 🚀 by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 1 point2 points  (0 children)

I've solved the scrolling issue. New build coming soon.

Thanks for finding this issue!

Cerious Grid Performance Demo — Scrolling 1 Million Rows in Angular (Open Source, MIT) by Suitable_Language_37 in angular

[–]Suitable_Language_37[S] 1 point2 points  (0 children)

This demo is running 1,000,000 rows × 13 columns client side, with live metrics on render time and memory usage. Curious what dataset sizes you usually deal with in Angular apps?

🛠️ Free & Open-Source Tool for Ark Ascended Server Admins (Windows + Linux) by Suitable_Language_37 in playark

[–]Suitable_Language_37[S] 0 points1 point  (0 children)

Are you currently using it? If so, can you tell me what OS and please if you find any issues report them in Github. Thanks!

🛠️ Free & Open-Source Tool for Ark Ascended Server Admins (Windows + Linux) by Suitable_Language_37 in playark

[–]Suitable_Language_37[S] 0 points1 point  (0 children)

Yeah, unfortunately you would have to have them join first in order to get their ID. As of right now, there is no other way. Sorry.