Software

• Stable Diffusion Web UI (A1111)   GitHub
• Comfy UI (Testing Only)   GitHub

Extension

• ADetailer   GitHub
• ControlNet   GitHub
• Dynamic Prompts   GitHub
• Negative Prompt Weight   GitHub
• Ultimate SD Upscale   GitHub

Models (1.5)

• Perfect Deliberate v5   Civitai
• Cyber Realistic v4.1   Civitai
• Realistic Vision v5.1   Civitai
• Dreamshaper v8   Civitai
• Elegance v5   Civitai
• Photon v1   Civitai
• AnReal v2   Civitai
• AniThing v2   Civitai
• MoltenArt v1   Civitai
• ReV Animated v1.2.2   Civitai
• Comic Babes v2   Civitai
• Nightmare Shaper v3   Civitai

LoRA's (1.5)

• Weight Slider   (deleted from Civitai)
• Baby Bumpers   (deleted from Civitai)
• Micro Waist   Civitai
• Noise Offset   Civitai
• Detail Tweaker   Civitai

Embeddings (1.5)

• Bad Artist   Civitai
• Bad Prompt   Civitai
• Cinematic Tools   Civitai

Models (XL)

• Starlight v3   Civitai
• Colorful v4   Civitai
• ProtoVision v0.6.3   Civitai
• Airtist Realistic v4.0   Civitai
• HelloWorld v6.0   Civitai
• ZavyChroma v0.7   Civitai
• Pony Diffusion v6   Civitai
• Pony FaeTality v1.1   Civitai
• Pony RealMix Final   Civitai

LoRA's (XL)

• Weight Slider   Civitai
• Fix Hands   Civitai
• BombShell   Civitai
• Detail Tweaker   Civitai
• Midjourney Mimic   Civitai

Upscaler

• NMKD 8x Superscale   Hugging Face
• NMKD 4x Superscale   Hugging Face
• Foolhardy 4x Remacri   Hugging Face
• 4x Lollypop   OpenModelDB

Updated: 25 June 2025

Introduction

ImGui styling is a kind of art in itself — but it’s not all that difficult. If you want a unique UI, you’ll need to work with color definitions, padding, and line flow. ImGui renders elements line by line, combining the padding from both the element and its window, so there are certain layout limitations — it’s not directly comparable to HTML + CSS.

My approach is a little complex, but it results in precise positioning across all resolutions. CET’s built-in scaling works surprisingly well and can be a big help if you don’t want to go full manual.

The reference documentation can be found in the CET GitHub repo. It lists all commands, though not very extensively.

Examples below are taken from CharLi, my playground for advanced ImGui styling.

Basic Styling

There are four main commands for styling and coloring elements. These are stack-based, so make sure to pop what you push — otherwise you’ll override other mods or even CET’s own windows. Failure to do so can lead to glitches or crashes.

Color definitions:

Style variables (like padding or alignment):

Each element has its own styleable parts — too many to list here. To explore them all, check the ImGui source. Color enums begin here.

For example, FramePadding affects windows, tab bars, tabs, collapsing headers, and more. Here's a basic window using padding and custom flags:

Coloring Elements

Styling colors works just like style vars. I like using 'ImGui.GetColorU32(r, g, b, a)' for RGBA colors. Values range from 0.0 to 1.0 for each channel.

The alpha channel controls transparency: 0.0 = fully transparent, 1.0 = fully opaque.

If your button is transparent and your window has its own background color, the button will inherit that look visually.

Now you’ve got a semi-transparent red window — no title bar, just vibes 😎

Fancy Icons

CET comes with a built-in library of glyphs (icon characters). They can be used anywhere text is accepted: button labels, window titles, tooltips, etc.

Browse icons at Material Design Icons, but note: the names are slightly different in CET’s file \cyber_engine_tweaks\scripts\IconGlyphs\icons.lua. For example: clock-outline on the MDI site = ClockOutline in CET.

We’ll give our red ghost window an absurd glyph-based title:

Layered Elements

This is a sneaky trick that works surprisingly well. ImGui allows negative spacers using ImGui.Dummy(), which acts as offset padding.

If you know the dimensions of an element, you can "rewind" the layout and overlap another — useful for custom toggles or visual gimmicks.

For instance, in CharLi I use a fake slider overlaying a transparent button — so the button handles input, while the slider delivers the style.

Step 1: Transparent Button

Step 2: Rewind

Step 3: Styled Slider Overlay

IMPORTEND: If a widget has no label (""), use PushID / PopID — otherwise, identical elements will share state and behave unpredictably.

And voilà — you’ve got a fully-styled, interactable FrankenWidget with decoupled input and visuals. Like dark UI necromancy in Lua 😄

This technique only works when you know the exact width of the elements and apply it on the same horizontal line. Vertical overlap between different rows isn’t possible — ImGui’s layout is strictly line-based.

to be continued...

GameOptions Has

Unfortunately, there's no method in the GameOptions family to check whether an option actually exists. Even worse: the return values of Get* methods can be misleading. If GameOptions.GetBool() returns false, there's no way to tell whether that's the actual setting — or just the fallback response for a non-existent option.

LUA Snippet

So I wrote a small workaround that helps with auto-detection. Note: It doesn’t prevent the “not found” message from appearing in the CET console.

Crashes Caused by Variable Names

Some bugs only show up once you launch the game — not while writing your CET mod. You might wonder why the game won’t start and spend half a day hunting for the cause. So I’m documenting these to help others avoid the same traps.

LUA Snippet

Defining a local variable with a leading underscore in global space can prevent Cyberpunk (and CET) from launching altogether.

Say no to cookies. Say yes to control.

RootPunk is not a website. It's a stance.

No tracking. No third-party scripts. No cookie banners haunting your scroll path. What you get is a clean byte stream from server to brain — built from first principles, without the crutches of modern web abstractions.

No Cookies. No Consent Walls.

The system stores nothing in your browser. No session IDs. No analytics. No fingerprinting.
It doesn’t ask for permission because it doesn’t need any.
Privacy by architecture — not by pop-up.

Server First. Always.

Everything is rendered server-side.
Even optional behaviors like quotes, previews or audio playback are resolved on the server and only optionally refined by JavaScript — never required.

There’s no “defer JS until ready” here. It’s already ready.

Built Bare-Metal

No frameworks. No NPM installs. No runtime bundlers.
Just raw PHP, SSI, and file reads — fast because it was always fast.

If you want to inspect how it works, just view source.
It’s not “minified” — it’s legible.

Design by Reduction

No loading screens. No infinite loaders. No 5MB of JS for a button.
If something doesn’t need to exist, it doesn't.

RootPunk removes more than it adds — until only clarity remains.

RootPunk isn’t minimalist because it’s cool.
It’s minimalist because it’s tired of pretending websites need to be complicated.

Multithreaded includes. Parallel assembly.

Rootpunk doesn’t render one step at a time — it composes its UI in parallel.

Thanks to NginX’s Server Side Includes (SSI), each <!--#include virtual="..." --> directive is handled concurrently by separate worker processes. That means your skin styles, navigation logic, Markdown content, random quote, and even base64-injected assets are all fetched and injected at the same time.

This is parallel layout assembly — and it feels instant.

Dynamic Assembly via PHP + SSI

The core loader boot.php includes partials via:

This allows highly granular, dependency-free templating. Since Nginx handles SSI concurrently, each include runs in parallel. You get multi-threaded layout composition without building or bundling anything.

SSI as a Templating Thread Pool

While frontend frameworks rely on hydration and client bootstrapping, Rootpunk resolves everything server-side. That includes:

• .css skin modules via <!--#include virtual="/api/min/skin/*.css" -->
• Image lists & Markdown renders via view-list.php, mad.php
• Audio players & dynamic quotes via Shared methods
• Favicon, silent MP3s & embedded icons via b64.php

Each include is its own thread, launched by Nginx, then composed into a single HTML payload.

What This Enables

• No layout blocking
• No partials or async fetches
• No DOM hydration
• No JavaScript required
• Just one payload — styled, routed, and content-complete

You’re not streaming chunks. You’re parallel-building a terminal UI that just arrives.

Architecture Notes

• SSI logic runs within the same request, not after
• No SSI recursion = full predictability
• Failures fall back cleanly (e.g. “NOT FOUND” or READY)
• APCu caching ensures redundant processing never happens

Rootpunk isn’t server-rendered in the classic sense — it’s pre-threaded, composed, and delivered with no client overhead.

Hydrated Corpse Problem

Most modern frameworks render HTML on the server, then ship JavaScript to “hydrate” the page — binding event listeners and unlocking interactivity after the fact. Until hydration finishes, the page might look alive but isn’t: buttons don’t respond, inputs fail, nav items are inert.

That’s what RootPunk avoids. There’s no waiting, no progressive wake-up, no fragile dance of scripts and markup.

Your page arrives fully usable from byte one — routed, styled, interactive if needed, and never dependent on JS execution. Even if a slow connection drops halfway through, the content is already rendered and navigable.

Hydration can create beautiful corpses. RootPunk prefers living systems.

Precomputed. Preencoded. Permanently efficient.

In RootPunk, cache isn’t a layer — it’s a design philosophy. There’s no loading spinner, no "checking for updates", no lazy database hooks.
Instead, you encode, compress, hash, and deliver — once.

Embedded Assets with base64

Icons, fonts and even the silent fallback .mp3 are embedded directly:

That’s not just compact — it’s an instant content pipeline.

Hash-based permanence

Every file in Rootpunk’s architecture — images, icons, audio — is encoded and cached with deterministic keys based on:

• File path
• filemtime() timestamp
• Resource intent (e.g. preview vs fullview)

This ensures that nothing is recalculated unless something actually changed. APCu stores the base64 blobs for a full 7 days, and NginX handles the rest through static caching rules.

It's not a cache hit or miss — it's cache like you mean it.

base64 as delivery

No <link>. No <script src>. No <img src="/favicon.ico">. RootPunk uses <!--#include virtual="/b64/..."> to inject assets inline — browser-decoded, CDN-free. This includes:

• favicons
• silent .mp3 preloaders
• images for AI-rendered galleries

Every file becomes a data URL, streamed directly with the page. That’s less “delivered on demand” and more “you already had it.”

APCu as memory extension

Why recalculate what you can remember?

• No file reads when not needed
• No base64_encode unless cache is cold
• No regeneration of preview images unless timestamps change

You’re not caching to speed things up — you’re preloading your own brain.

Multi-Subdomain Sharding

Gallery images (/view-scan.php) are distributed over subdomains:

Browsers increase parallel load limits per domain — sharding gives you more lanes on the highway. And since these are hash-based, they’re cacheable indefinitely on the client side.

No Cache. No Panic.

If an image isn’t found in the local cache? RootPunk renders it on the fly, injects a watermark, writes it into /cache/, and responds with Content-type: image/jpeg.

There’s no fail. Just fallback.

Filesystem & NAS Architecture

RootPunk doesn’t store assets — it mounts volumes of meaning.

Media is served from a remote 6-Bay SSD NAS connected via NFS, mounted directly into your runtime layout. With over 7TB combined capacity and read speeds that make local disks blink, this setup keeps the main machine light and the payload heavy.

• /www/image → X.X.X.X:/volume/image
• /www/music → X.X.X.X:/volume/music

AI images and music live externally, but feel local — indexed, hashed, and rendered on demand. Cache warmers like APCu handle re-requests gracefully, and if a NAS share is temporarily offline, Rootpunk degrades with dignity and fallback logic.

You didn’t just add storage — you added remote consciousness.

Modular Page Composition

Each content section (/r, /ai, /mod, /tech) is pre-routed using CSS <input type="radio"> toggles with corresponding labels. No JavaScript needed for state — it’s handled by the browser’s rendering engine through CSS selectors. Navigation becomes a declarative UI state machine.

These inputs allow each section to be toggled via radio IDs — with zero client script.

Optional JS. Maximal intent.

RootPunk isn’t powered by JavaScript — it’s enhanced by it.
All interactive behavior is fully optional and only kicks in when allowed. No UI element needs scripts. But when JS is present, it activates intelligent patterns: inline audio player state, playlist tracking, bootloader visuals, and more — all seamlessly, all featherlight.

Audio Player Awareness

The music player responds to play(), pause() and ended — updating the DOM, switching visual state, and even remembering the song quote it replaced.
Playback isn't “streamed” — it’s rendered, and then rehydrated by minimalist logic:

If JS never runs, the original quote remains. If JS runs, the interface breathes.

Quote of the Moment

The system injects dynamic flavor via randomized statements from Shared::GetQuote() — prebuilt in the PHP core and rotated on each reload:

This further proves: no clientside logic, all flavor, full identity.

Bootscreen Animation

When a CSS variable says --sw-boots: yes, RootPunk boots. Like, literally — line by line, typing out its own diagnostics panel:

'SYSTEM BOOT v1.1'
'>> SYSTEM DIAGNOSTICS'
'   CPU ............ OK'
'   CACHE .......... SYNCED'
'   SHARDS ......... ONLINE'
No frameworks. No dependencies. Just a <div> injected with conviction.
JS Respect Mode
The page:
works entirely without JavaScript
hides JS-only features when not available
injects logic only when the DOM is ready
This isn’t progressive enhancement. This is consensual execution.
Playback Fail-safety
The music system even detects and recovers from:
file load aborts
broken connections
empty sources
player.addEventListener('error', function(){
  if (player.src !== "/music/silence.mp3") {
    player.load();
  }
});
It’s a playlist built like a rover: it reboots when it coughs.
RootPunk doesn’t need JavaScript. It just treats it like a loyal sidekick — useful, clever, and never in control.