| Welcome, Guest |
You have to register before you can post on our site.
|
| Online Users |
There is currently 1 user online
» 0 Member(s) | 1 Guest(s)
|
| Latest Threads |
News [9/15/2026]
Forum: [Site] News - Photonamus.com
Last Post: Photonamus
09-15-2026, 03:12 PM
» Replies: 0
» Views: 35
|
News [9/9/2026]
Forum: [Site] News - Photonamus.com
Last Post: Photonamus
09-09-2026, 06:35 AM
» Replies: 0
» Views: 38
|
Creative Toolchain Packag...
Forum: [Site] AI Library - Photonamus.com
Last Post: Photonamus
09-09-2026, 05:38 AM
» Replies: 0
» Views: 33
|
News [9/8/2026]
Forum: [Site] News - Photonamus.com
Last Post: Photonamus
09-08-2026, 02:20 PM
» Replies: 0
» Views: 43
|
Creative Tool Chain Packa...
Forum: Public AI Context Library
Last Post: Photonamus
09-08-2026, 01:05 PM
» Replies: 0
» Views: 34
|
News [9/7/2026]
Forum: [Site] News - Photonamus.com
Last Post: Photonamus
09-07-2026, 11:55 AM
» Replies: 0
» Views: 45
|
Security Updates [9/7/202...
Forum: [Site] News - Photonamus.com
Last Post: Photonamus
09-07-2026, 11:40 AM
» Replies: 0
» Views: 39
|
News [9/4/2026]
Forum: [Site] News - Photonamus.com
Last Post: Photonamus
09-04-2026, 04:49 AM
» Replies: 0
» Views: 46
|
Account Activation [9/4/2...
Forum: [Site] News - Photonamus.com
Last Post: Photonamus
09-04-2026, 04:42 AM
» Replies: 0
» Views: 43
|
Sony: A Company At War Wi...
Forum: Article Discussion
Last Post: Photonamus
08-27-2026, 03:07 AM
» Replies: 0
» Views: 53
|
|
|
| BBCode Cheat Sheet / Examples |
|
Posted by: Photonamus - 08-20-2026, 08:59 PM - Forum: [Forum] Tutorials
- No Replies
|
 |
BBCode Cheat Sheet — Copy & Paste Into a MyBB Post
Paste everything below this line into a new MyBB thread:
BBCode Cheat SheetA quick reference for formatting your posts on this forum.
Text Formatting
Bold
Code: [b]Bold text here[/b]
Code: [i]Italic text here[/i]
Code: [u]Underlined text here[/u]
Code: [s]Strikethrough text here[/s]
Code: [b][i]Bold and italic combined[/i][/b]
Text Size
Extra small text
Code: [size=x-small]Extra small text[/size]
Code: [size=small]Small text[/size]
Code: [size=medium]Medium text (default)[/size]
Code: [size=large]Large text[/size]
Code: [size=x-large]Extra large text[/size]
Code: [size=xx-large]Huge text[/size]
Text Color
Red text
Code: [color=red]Red text[/color]
Code: [color=#00FF00]Custom hex color[/color]
Code: [color=blue]Blue text[/color]
Font
Monospace font
Code: [font=Courier New]Monospace font[/font]
Code: [font=Georgia]Serif font[/font]
Text Alignment
Left aligned (default)
Code: [align=left]Left aligned[/align]
Center aligned
Code: [align=center]Center aligned[/align]
Right aligned
Code: [align=right]Right aligned[/align]
Links
Auto-linked URL:
Code: https://photonamus.com
Code: [url=https://photonamus.com]Visit Photonamus[/url]
Images
Basic image:
Code: [img]https://example.com/image.png[/img]
Code: [img=400x300]https://example.com/image.png[/img]
Lists
Bullet list:- []First item []Second item []Third item
Code: [list] [[/i]]First item [[i]]Second item [[/i]]Third item [/list]
- []First item []Second item []Third item
Code: [list=1] [[/i]]First item [[i]]Second item [[/i]]Third item [/list]
- []First item []Second item []Third item
Code: [list=a] [[/i]]First item [[i]]Second item [[/i]]Third item [/list]
Quoting
Basic quote:
Quote:This is a quoted block of text.
Code: [quote]This is a quoted block of text.[/quote]
Username Wrote:Something that user said. Code: [quote='Username']Something that user said.[/quote]
Code Blocks
Use code blocks for sharing code, configs, terminal commands, or anything you want displayed exactly as typed without formatting:
Code: Just wrap your content in code tags to show it raw.
(We can't show the actual tags inside a code block without them working, so just type the word "code" inside square brackets to open, and "/code" inside square brackets to close.)
Horizontal Rule
A horizontal line divider (like the ones throughout this post):
Spoiler / Hidden Content
Click to reveal hidden content: [spoiler]This was hidden until you clicked![/spoiler]
Code: [spoiler]This was hidden until you clicked![/spoiler]
Videos
YouTube video:
Code: [video=youtube]https://www.youtube.com/watch?v=VIDEO_ID[/video]
Combining Tags
You can nest tags inside each other for more complex formatting:
Bold, red, and large!
Code: [b][color=red][size=large]Bold, red, and large![/size][/color][/b]
Centered Heading With a subtitle underneath
Code: [align=center][b][size=x-large]Centered Heading[/size][/b] [i]With a subtitle underneath[/i][/align]
Tips- []Always close your tags. Every opening tag like needs a closing tag like . If your post looks weird, you probably forgot to close something. []Nest tags in the right order. Close inner tags before outer ones. Think of them like layers — last opened, first closed. []Preview your post. Hit the Preview button before posting to make sure everything looks the way you want. []Use the toolbar. The editor toolbar above the text box has buttons for most of these. Highlight text and click a button to wrap it in the right tags automatically.
Questions about formatting? Reply below and we will help you out.
|
|
|
| cbk-next Support for Corsair M65 Ultra |
|
Posted by: Photonamus - 08-20-2026, 06:25 AM - Forum: General Projects Discussion
- No Replies
|
|
CKB-NEXT: M65 RGB ULTRA
Linux driver support for Corsair M65 RGB Ultra — contributed upstream to ckb-next
C • Linux • Bragi Protocol • Reverse Engineering • Open Source
WHAT THIS IS
The Corsair M65 RGB Ultra is a wired gaming mouse (USB ID 1b1c:1b9e) that had zero Linux support. Every other M65 variant uses Corsair's legacy NXP protocol. The Ultra doesn't — it uses Bragi, a newer protocol that shares nothing with NXP at the wire level. Nobody knew this. The existing device request sat open on GitHub since 2022.
This contribution adds full support: cursor, all 8 buttons including sniper, scroll, DPI control, and RGB lighting across all three zones. It was submitted as PR #1332 to the ckb-next project.
4 files changed · +72 / -12 lines · USB ID 1b9e · issue open since 2022
THE DISCOVERY
The M65 RGB Ultra's firmware does something deceptive: it ACKs legacy NXP commands without applying them. You send an NXP lighting command, the device responds with a proper acknowledgment on the command endpoint ( 07 22 00 00 ...), and nothing happens. No error, no rejection — just silence on the hardware. This is why treating it as an NXP clone of the M65 RGB Elite never worked, and why the issue sat open for years.
The answer came from USB traffic captures with usbmon. NXP writes completed successfully with zero hardware effect. The Bragi handshake returned real data — firmware version, poll rate, brightness — where NXP returned all zeros or failures. The device is Bragi. Once that was established, the actual code changes were surgical.
DEVICE SPECIFICS
Quote:No Report ID prefix — HID mouse reports arrive raw: byte 0 is buttons, bytes 1–4 are X/Y as int16 little-endian, byte 5 is wheel. Every other mouse in the codebase has a Report ID prefix byte. New translation function required.
3 lighting zones — Logo, scroll wheel, DPI indicator. The device sends them in that order, but the shared M65E GUI layout expects a different mapping. Zone reorder array {0, 2, 1} handles the translation. Zone count cross-checked against OpenRGB's CorsairPeripheralV2 table.
Button mapping — All 8 buttons arrive in one byte in straight bit order. Calibrated by capture: 0x08 back, 0x10 forward, 0x20 DPI up, 0x40 DPI down, 0x80 sniper.
Wheel data — Only exists in the HID packet, not in the Bragi software packet. Device added to SW_PKT_HAS_NO_WHEEL macro.
THE CODE
Five files, each handling a different layer of device support.
src/daemon/usb.h — device definition, macros, protocol registration
Code: // Product ID definition
#define P_M65_RGB_ELITE 0x1b5a
#define P_M65_RGB_ULTRA 0x1b9e // <-- NEW
#define IS_M65(kb) ((kb)->vendor == V_CORSAIR && ...)
// Added to IS_MOUSE macro
(product) == (P_M65_RGB_ULTRA) ||
// Added to SUPPORTS_ADJRATE macro
(kb)->product == P_M65_RGB_ULTRA ||
// New macro — devices with no HID Report ID prefix
#define HAS_HID_NO_REPORTID(kb) ((kb)->product == P_M65_RGB_ULTRA)
// Added to USES_BRAGI macro
(product) == (P_M65_RGB_ULTRA)
// Added to SW_PKT_HAS_NO_WHEEL macro (wheel only in HID packet)
(kb)->product == P_M65_RGB_ULTRA
— device table, DPI range, product string
Code: // DPI list — Ultra supports up to 26000
{ P_M65_RGB_ELITE, 18000 },
{ P_M65_RGB_ULTRA, 26000 }, // <-- NEW
// Device model table
{ V_CORSAIR, P_M65_RGB_ELITE, },
{ V_CORSAIR, P_M65_RGB_ULTRA, }, // <-- NEW
// Product string — shares "m65e" layout with the Elite
- if(product == P_M65_RGB_ELITE)
+ if(product == P_M65_RGB_ELITE || product == P_M65_RGB_ULTRA)
return "m65e";
— input translation, button LUT, HID parsing
Code: // New function declaration
static void hid_mouse_translate_noreportid(usbinput* input, int length,
const unsigned char* urbinput);
// Bragi input routing — added no-reportid branch
if(buffer[1] == BRAGI_INPUT_HID && urblen == 64) {
corsair_bragi_mousecopy(targetkb, &targetkb->input, buffer);
} else if(HAS_HID_NO_REPORTID(targetkb)) {
// No Report ID prefix: buttons at byte 0, XY at bytes 1-4
hid_mouse_translate_noreportid(&targetkb->input, urblen, buffer);
} else {
// New translation function — raw HID with no Report ID
static void hid_mouse_translate_noreportid(usbinput* input,
int length, const unsigned char* urbinput){
if(length < 6){
ckb_err("Invalid length %d", length);
return;
}
for(int bit = 0; bit < BUTTON_HID_COUNT; bit++){
if(urbinput[0] & (1 << bit))
SET_KEYBIT(input->keys, MOUSE_BUTTON_FIRST + bit);
else
CLEAR_KEYBIT(input->keys, MOUSE_BUTTON_FIRST + bit);
}
input->rel_x += (urbinput[2] << 8) | urbinput[1];
input->rel_y += (urbinput[4] << 8) | urbinput[3];
input->whl_rel_y = (signed char)urbinput[5];
}
// Button lookup table — all 8 in straight bit order
const unsigned char m65_ultra_lut[BRAGI_ONE_BYTE_MOUSE_BUTTONS] = {
0x00,
0x01,
0x02,
0x03, // back
0x04, // forward
0x05, // dpi up
0x06, // dpi down
0x07, // sniper
};
// Added M65 Ultra to one-byte button device list + LUT routing
|| kb->product == P_M65_RGB_ULTRA))
else if(kb->vendor == V_CORSAIR && kb->product == P_M65_RGB_ULTRA)
lut = m65_ultra_lut;
— RGB lighting, zone mapping, LED offset
Code: // LED zone count — 3 zones: logo, scroll wheel, DPI indicator
LED_CASE_M(P_M65_RGB_ULTRA, 3);
// Zone reorder — device order doesn't match GUI layout
if(kb->product == P_M65_RGB_ULTRA){
// Device zone order: logo, scroll wheel, dpi indicator
// GUI order: back, dpi, wheel — swap last two
static const uchar zmap[3] = {0, 2, 1};
bytes *= 3;
for(size_t i = 0; i < zones; i++){
pkt[7 + i] = newlight->r[led_offset + zmap[i]];
pkt[7 + zones + i] = newlight->g[led_offset + zmap[i]];
pkt[7 + zones * 2 + i] = newlight->b[led_offset + zmap[i]];
}
}
// LED offset — M65E layout has no "front" zone, start at back
- return updatergb_bragi(kb, force, LED_MOUSE);
+ const size_t led_offset = LED_MOUSE +
+ (kb->product == P_M65_RGB_ULTRA ? 1 : 0);
+ return updatergb_bragi(kb, force, led_offset);
TESTING
Developed and tested with an M65 RGB Elite and the Ultra connected simultaneously. Verified on hardware: cursor tracking, all 8 buttons including sniper hold with DPI shift and light change, scroll wheel, DPI stage switching, all three lighting zones with per-zone independent colors, GUI key rebinding — across daemon restarts and USB replugs. The NXP code path is completely untouched, so existing devices are unaffected by construction.
TRANSPARENCY
This was a human-driven hardware debugging effort done in collaboration with an AI assistant (Anthropic Claude). Every change was motivated by wire-level evidence — usbmon captures, daemon debug logs, button-by-button calibration — and verified on the physical hardware before the next step. The AI disclosure is included in the commit and PR description. This is how AI-assisted open source contribution should work: full transparency, real engineering, no black boxes.
VIEW PR #1332 ON GITHUB ↗
|
|
|
|
| Status: 8/20/2026 |
|
Posted by: Photonamus - 08-20-2026, 06:06 AM - Forum: [Forum] News & Updates
- No Replies
|
|
Email verification for sign ups coming soon. I will be manually verifying until then.
Themes and accounts coming to the site end to match across the site/forum.
Building a new system to handle news across site/forum.
Once these things are done we are going to do a polish and bug stomp round on this and everything should be looking good. We are up and running after that. From that point we will just be adding features and expanding things as we go.
|
|
|
|
| My Philosophy [How We Got Here] |
|
Posted by: Photonamus - 08-19-2026, 04:14 AM - Forum: Self-Hosting / Infrastructure Discussion
- No Replies
|
|
About 7 to 8 months ago as of writing this I deleted my windows partition and installed linux. I never used linux didn't know much about it at all actually. I just saw win11 and decided no I was not going to install that this time. I was going to install linux and learn that not another new windows version this time. What a smart move that turned out to be. I was a windows specialist I spend decades in windows only. We are talking 3.11 to 10. I knew the system inside and out. What I did not know was how good the alternatives were. Why? Oh because I knew windows my software all ran under it all the usual lazy answers for not switching. Then when 11 released and was a mess I thought why not see what else there is? I should mention that I also dumped adobe and I was a master with that software too. I was there for the newgrounds flash animation era and I did a lot of work with adobe stuff. I swapped tools I swapped OS all of it in one shot. It wasn't even hard LOL. I thought it would be hard I thought stuff I used would not exist (it don't) but the interesting part was that there was an option here that often worked better than the windows tool I had before. I found killer replacements for things I could not even find alternatives to in windows. Most stuff I needed was a simple search away.
So what is the point am I just bragging on my forums? Not at all. Read what I just wrote in that line. My own forums exist and I am running the server I built from scratch loaded with a linux server flavor and then built all of this to run on it from scratch not a template. Well the site and it's stuff from scratch and all the forum themes. It's mybb by choice I wanted the classic stuff but modernized for a forum experience specifically. The site and forums are becoming a single seamless experience though. And this is the point. I swapped my entire experience out then built all this on the new one not the old one. This was ALL done while I was only 6 months into linux as a new user who never touched it.
Now if I can build all this as a new guy on linux and run 2 servers on my network with it and having never run a server I see no reason not to give it a shot just saying.
I'm not here to shout about how awesome linux is. It's an OS they all have quirks you need to learn and work around. What I am here to do is set a clear example of how easy it is to make a move that big in one shot. It is not impossible and this is evidence to prove that.
What else did I do? I took control over all of my stuff. I built every piece of hardware in my stack myself. I loaded all of it and made it do what I wanted. I don't have anyone between me and my stuff. I am one of those guys. I cut out middlemen and I do my own thing. That's the philosophy. It isn't new I am just making an example here and showing that it can be done this way. And just how far you can take all of it.
I think I am 6 weeks in now on this complete web stack build. Site needs some stuff I am a ways form done yet. Once it's up and built it just works. This is maybe an 8 week process today if you have something like claude code to use. I ran a 20 a month account and did all this at the speed of light. Most of my AI is local tooling not frontier model. I generate music with ACE-Step not suno. I use ComfyUI for graphics not some online paid stuff. My phones all have local models but can also request a model from my desktop from anywhere. Nothing like giving my phone the power of my pc on loan just saying.
I went further than my machine and servers. I completely removed windows from my network outside my kid's xbox and we are replacing that with a minipc soon. That's his next console not one because they are a scam box that charges a monthly fee to connect to his friends. He spends more time on his bazzite machine than he does that thing. We want to build a minipc and load it with steamos next. Notice we are building our own hardware and just using the free os. That's because I don't even agree with steam anymore.
Own your stuff fellas. Don't ask permission. It's easier than you think.
|
|
|
|
| PhotonamusWeb - This Infrastructure |
|
Posted by: Photonamus - 08-14-2026, 12:28 PM - Forum: Self-Hosting / Infrastructure Discussion
- No Replies
|
|
So I thought maybe I should explain the actual infrastructure behind these forums and the website and stuff. Basically this post is going to document what is going on for anyone else interested in standing up their own web stack.
I will cover the hardware I use and all of the costs involved (not much) and the process I used to get this all up and running the way it is now.
So first off let's get right into the core of this whole thing the hardware. What is PhotonamusWeb? That is the name of the server all of this runs off of. I run a pair of servers actually. The first is a tiny pi4 running 17 services that are all facing my own home network. It serves the house and any internal network stuff. We will cover that thing in a different post later on it needs it. And the other server is the one this stuff runs off of. This one has all the public outward facing stuff on it. 2 servers 2 jobs serving inward and outward from my network.
Ok so let's take a quick look at said hardware for a moment.
![[Image: photonamus-web.jpg]](https://photonamus.com/images/photonamus/photonamus-web.jpg)
PhotonamusWeb — STGAubron ABR0222 Gaming Diamond
---------------------------------------------------------------------------------------------------------
CPU: Intel Core i7-4790 @ 3.60GHz (Haswell, 4 cores / 8 threads, LGA 1150)
Motherboard: STGAubron Intel B85 (LGA 1150, Haswell chipset)
RAM: 16GB DDR3 (2x 8GB @ 1333 MT/s)
GPU: NVIDIA GTX 1660 Ti 6GB GDDR6 (present but unused — headless)
Boot Drive: Western Digital Green 240GB SATA SSD
Storage Drive: Western Digital Blue 1TB SATA SSD (mounted at /mnt/storage)
Network: Gigabit Ethernet, WiFi 6 + Bluetooth 5.0 (unused)
Chassis: Mid-tower, white, 8x RGB fans
OS: Ubuntu Server 26.04 LTS
-------------------------------------------------------------------------------------------------------
So this is our server and the site/forums and other stuff is all running off of this one little box. It is not breaking a sweat to do this. Is this fantastic hardware? Nope this is FREE hardware LOL. But it works and I have zero investment in hardware only my time. I cleanup the machine and went over everything made sure it was all working and in good order. A refurb job essentially. Once that was done I loaded it up with ubuntu server as a headless server. I did this from my own machine. Both servers work this way they are headless and I can ssh into them and use terminal to do the work. As for a web address? A .com address through cloudflare at the time of purchase was $10.48 USD. I also use claude code to write most of the stuff and get work done fast. So I have a $21.50 a month bill for that. Though once the site is up forums work and everything is built it becomes manageable from my end without anything else. Use the big tools to stand it up then build some systems to update and manage it and it just works basically. It's not exactly difficult these days or expensive either. No excuses get those servers up fellas we need em  I will be coming back to this one with a lot more information on the process later but I wanted to at least give everyone a look at what is going on and how it became possible.
|
|
|
|
| Current Status [8/12/2026] |
|
Posted by: Photonamus - 08-12-2026, 06:47 PM - Forum: [Forum] News & Updates
- No Replies
|
|
Place is looking sharp but isn't done yet. We are working on the mobile friendly version today.
Categories exist. More can be created based on demand. If you think something makes sense please suggest it.
The plan today is to get the current theme to adjust for mobile. Once that is done I am going to add variations of the theme for light/dark and you will have some options to choose from for a theme.
The forums account is going to also link users site side data so that themes carry over from the forum to the site. It will track shop activity for purchases later also and it will store your radio data like playlists favorites etc in there. The site may require a lot of work to make all this happen. More on that below.
The site is potentially getting a rebuild. I am happy with the design but I need the entire thing to be more flexible. A lot of this has to do with the news feed and themes. I need the design to be easier to work with on my end basically. Right now I have to rebuild it every time I update it. We are changing this to allow easy updates in pieces. I can push a news update or new theme in seconds without much work if I design it correctly. So the site may undergo some major changes on the back end of things but should appear the same from a visitor perspective.
It's coming together now. This place is at least looking consistent and feeling right. Stay tuned for more.
UPDATE:
10 themes are in. We need matching logos yet which is coming next. I can easily add more options suggestions for color combinations are open.
To change the theme: User CP > Edit Options
You will see a box to change the theme from default to one of the new theme options (Light) or (Dark)
Known Issues: The edit options page on mobile will not scroll right which cuts off features. Fix coming soon.
|
|
|
|
| Speaking in Tongues: When Language Becomes a Trojan Horse |
|
Posted by: Photonamus - 08-03-2026, 09:46 AM - Forum: Article Discussion
- No Replies
|
|
Speaking in Tongues
When Language Becomes an Emotional Trojan Horse
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
You've heard someone talk and something about it bothered you. Not what they said — you can handle disagreement. Something about how they said it. The words were all real words, the sentences were grammatically valid, but when you tried to actually engage with what was said, there was nothing to grab onto. It slid off your brain like oil on glass. And then you felt something. Not understanding. Not agreement or disagreement. Just... a feeling. One that wasn't yours a minute ago.
Congratulations. You just got hit with an emotional payload disguised as language.
─── ◆ ───
The Channel Mismatch
Language is a system built for meaning. It evolved to encode propositions — claims about reality that you can examine, challenge, agree with, or reject. "The river is flooded" points at something real. You can look where the words are pointing. That's the whole contract of language: I make a claim, you evaluate it, and we build shared understanding from the exchange.
But there's a thing that happens when people use the structure of language — the grammar, the syntax, the shape of a reasonable statement — to carry something that isn't a proposition at all. The emotion is the payload. The words are just the carrier wave. And because the words still look like statements about reality, your mind tries to parse them as statements. It tries to find the thing they're pointing at. And there's nothing there.
That's the channel mismatch. It's the equivalent of trying to send music through a fax machine. The fax machine will dutifully transmit something, but what comes out the other side is noise — not because the music wasn't real, but because the channel wasn't built for it.
─── ◆ ───
Why It Feels Like Being Lied To
Here's the part that's hard to articulate and easy to feel. When someone speaks to you using language, there's an implicit promise baked into the act: "I am making a claim you can evaluate." That's not a formal agreement anyone signed. It's deeper than that. It's the foundational contract that makes language work as a communication tool between humans.
When someone hijacks the structure of a claim to deliver pure affect, the promise is broken but the form of the promise is still there. You're handed what looks like an argument but is actually a mood. And now you're stuck in a weird position. If you try to respond to it as an argument — "that doesn't make sense" — you look like you're missing the point. If you respond to it as a mood — "sounds like you're upset" — you've abandoned the shared framework of meaning that language is supposed to provide. Either way, you lose.
That's not an accident. That's the mechanism working as designed.
─── ◆ ───
It's a Translation Problem
Humans have native channels for emotion. Crying. Music. Art. Silence. Physical presence. A look on someone's face. These are formats that carry emotional data without pretending to be something else. When you hear a sad song, you don't try to fact-check it. The channel matches the content.
What's happening with this type of speech is a forced translation. Someone has an emotional state and instead of expressing it through a native channel, they serialize it into language. They take something that isn't propositional and force it through a propositional system. The result is like shoving a square through a round hole — something comes out the other side, but it's warped and wrong, and the wrongness is precisely what creates that uncanny feeling you can't easily name.
It's not quite lying. It's not quite manipulation. It's not quite nonsense. It's a weird middle zone where all the surface features of coherent speech are present but the underlying content is something else entirely. That's why it takes so long to figure out what's bothering you about it. The disguise is baked into the delivery mechanism.
─── ◆ ───
The Megaphone Problem
In a small room, this behavior gets checked. Someone talks like this and eventually somebody says "what are you actually saying?" The room watches the exchange. The speaker either clarifies — in which case it was just poor communication — or they can't, because there was nothing to clarify. Social pressure maintains the contract. The feedback loop works.
Social media handed these people a megaphone and pointed it at the entire world.
Now there's no room. No social pressure. No cost for broadcasting your internal emotional state at millions of strangers who didn't ask for it, don't want it, and can't do anything about it. The platforms don't care — they reward it, because emotional payload drives engagement. People either resonate and amplify, or get angry and respond. Both count the same to the algorithm.
The people who would challenge it are now outnumbered a thousand to one by the instances of it. You can't correct a flood one bucket at a time.
─── ◆ ───
The Manipulation Layer
Here's where it gets darker, and where the thing earns a harder name than "miscommunication."
If someone trauma dumps on you — just unloads their raw experience in your direction — you can at least see what's happening. You can look at them and say "I didn't ask for this." It's rude, maybe, but the boundary is clear and the situation is legible.
This is different. The words aren't a direct log of experience being overshared. They're constructed to hold your attention. The propositional packaging forces you to unpack it before you can reject it, and by the time you've figured out there's no propositional content, you've already absorbed the emotional payload. If someone screams at you, you know in an instant what happened and you can decide how to respond. If someone wraps the scream in the syntax of reasonable speech, you have to decode it first. That delay is the weapon.
That's not miscommunication. That's manipulation. The packaging exists specifically to prevent you from walking away for the two seconds it takes the payload to land.
─── ◆ ───
The Tolerance Problem
Here's where it connects to something bigger.
When boundary enforcement gets socially penalized — when "stop doing that" or "that doesn't make sense" carries a social cost — the boundary violations don't hold steady. They escalate. Why wouldn't they? If the cost of pushing is zero and the cost of pushing back is punishment, the rational move for anyone inclined to push is to push forever.
And the cultural norm shifted in exactly the wrong direction. Challenging someone's emotional expression became coded as cruelty rather than boundary enforcement. Setting a boundary — "I didn't ask for this, your words don't mean anything, you're dumping on strangers" — got reframed as a lack of empathy. So the people doing the manipulating got a shield for free. Anyone who calls it out looks like the bad guy.
This is the Chernobyl pattern. The Soviet system punished people for reporting problems, so everyone developed elaborate systems for not reporting them. The information that could have prevented the disaster existed. People knew things were wrong. But the cost of saying so was destruction, so they passed the lie upward and each layer added its own lie on top. The silence looked like stability. Right up until the reactor blew.
When you punish small corrections, you don't get stability. You get pressure accumulation. And pressure that isn't released in measured increments gets released all at once.
─── ◆ ───
The Snapback
The correction has already started. You can feel it if you're paying attention. Things that were unsayable two years ago are getting said. The social cost of saying them is dropping, and that drop is accelerating, because each person who pushes back and survives lowers the cost for the next person.
That's an exponential adoption curve. It looks flat for a long time because the early adopters pay the highest price. Only the people who genuinely don't care about social punishment step out first. But each one lowers the threshold slightly. At some point, the cost drops below what an ordinary person is willing to pay, and then it's not a trickle. It cascades.
The question isn't whether the correction is coming. It's whether it arrives as a controlled shutdown or as a meltdown.
If people rediscover boundaries now — draw lines, take the accusation of cruelty, don't flinch, move on — that's the controlled version. It's proportional. It distinguishes between genuine vulnerability and manipulation. It preserves the things worth keeping while removing the things that need to go.
If the pressure builds until it breaks on its own, it's indiscriminate. The snapback hits the manipulators and the genuinely vulnerable alike, because by that point nobody has patience left to sort one from the other. The cultural cruelty that should have been applied in small, targeted, proportional doses arrives all at once as something much uglier.
─── ◆ ───
What To Do About It
This part is simple. Not easy, but simple.
When someone speaks to you and the words don't resolve into meaning — when you feel an emotional response but can't find a propositional claim to engage with — name it. Not in your head. Out loud. "What are you actually saying?" Not as a challenge. As a genuine question. Force the translation back into the source format. Either they have something real to say and they'll find a way to say it clearly, or they don't, and the absence speaks for itself.
When you get called cruel for it, don't argue. Don't defend. Don't explain. Say "yeah, maybe" and hold the line. The accusation only has power if you grant it power. The entire strategy depends on you caring more about being seen as kind than about maintaining the contract that makes language work.
The megaphone is there for anyone. The people blasting noise aren't going to stop on their own. But the channel belongs to all of us, and every time someone uses it to carry signal instead of noise, the signal-to-noise ratio improves by one.
Start transmitting.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
|
|
| Programmable Shader Model for Thinking |
|
Posted by: Photonamus - 08-03-2026, 09:46 AM - Forum: Article Discussion
- No Replies
|
|
The Programmable Shader Model for Thinking
How watching hardware evolve for thirty years taught me
to think about everything
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
─── ◆ ───
Pong Was Not a Computer
Here is something most people never think about. Pong had no processor. There was no CPU, no code, no software of any kind. It was a handful of logic gates wired together on a board that used the television's own electron beam as a clock. The ball was a counter. The paddles were counters. Collision detection was a few gates comparing counter values. When the beam's position matched the ball's counter, the signal went white. That was the entire game. The hardware was the game. There was nothing to reprogram because there was nothing programmed in the first place. You would have to physically rewire the board to make it do something different.
This is where the story starts, and most people skip right past it because it does not look like anything we would call a game today. But if you were actually there, and you paid attention, this is where the pattern begins.
─── ◆ ───
The Console Is a Hardware Engine
When the Atari 2600 came along in 1977, it introduced a real CPU — a MOS 6507 — alongside a custom chip called the TIA that handled video. But the TIA was barely a graphics chip. It could draw a background, two player sprites, two missiles, and a ball. Five objects total. Everything else had to be faked by the CPU in real time, synchronized to the television beam as it physically swept across the screen line by line. If you wanted more than two sprites visible, you had to wait for the beam to pass the first one, then rewrite the sprite data before it reached the spot where you needed the next one. Miss your timing by a few cycles and you got visual garbage on screen.
There was no frame buffer. The 2600 had 128 bytes of RAM. Not kilobytes. Bytes. The image on screen only existed in the moment the beam painted it, driven by code that was essentially a real-time control loop racing against analog television hardware.
This is what brute-forcing graphics through a CPU actually looked like. No dedicated rendering hardware doing the heavy lifting. Just a processor running flat out trying to keep up with the physical beam.
The NES changed this by adding a dedicated Picture Processing Unit — the PPU — that maintained its own memory, stored tile and sprite data, handled background scrolling, and did its own rendering pass independent of the CPU. Now the CPU's job shifted from "manually construct every scanline in real time" to "describe the scene and let the PPU draw it." The architectural split between game logic and rendering had begun.
But every console PPU was fixed-function. It drew tiles on a grid and sprites on top of them, with fixed palettes, fixed sizes, and fixed rules. You could not ask it to do anything it was not wired to do. Each console was a different opinion about what the hardware should be able to do, baked permanently into silicon. The console was not running a game engine. The console was the game engine.
─── ◆ ───
The PC Had No Such Luxury
While consoles had dedicated graphics hardware with specific capabilities, the PC had almost nothing. Through the late 1980s and into the mid 1990s, the VGA card was basically a dumb frame buffer — a block of memory that mapped to pixel output. The CPU had to calculate every single pixel and write it into that memory directly.
This is the era of Wolfenstein 3D and Doom. John Carmack wrote renderers that were pure software — the CPU determined what color every pixel should be, thirty-ish times per second, using clever math like BSP trees for visibility and vertical strip rendering for walls. The entire "engine" was a C program doing enough math fast enough to fill a 320 by 200 pixel buffer before the next refresh.
This is also where the concept of a game engine as a separable thing first crystallized. Doom's renderer, physics, map format, and entity system were licensed to other developers who built entirely different games on top of them. The engine was the machinery. The game was the content you fed into it. That separation had real commercial value, and it proved the two things could be decoupled.
Quake pushed the CPU-only approach to its absolute ceiling. True 3D polygons, full projection pipeline, perspective-correct texture mapping, real lighting. Software rendered on a Pentium. It worked, but it was brutal. That ceiling was real and everyone could feel it.
─── ◆ ───
So We Added Specialized Hardware Again
The 3dfx Voodoo showed up in 1996 and did exactly one thing: rasterize textured triangles with z-buffering in dedicated hardware. The CPU still handled all the game logic, geometry transformation, and scene management. But instead of the CPU also having to fill every pixel, it handed finished triangles to the Voodoo card and the Voodoo drew them. The performance difference was staggering.
This was the exact same move the console makers had made years earlier — offload the rendering to a chip that is purpose-built for that job. The industry went from specialized hardware to general-purpose CPU and back to specialized hardware because the general-purpose approach hit a wall. The Voodoo was conceptually the same thing as the NES PPU, just solving a much harder version of the problem.
But early GPUs were still fixed-function. The Voodoo did texture mapping and z-buffering and that was it. You could not change how it textured or how it lit. You configured the pipeline they gave you. You did not program it.
The real shift came around 2001 with programmable shaders. Instead of a fixed lighting equation baked into silicon, you could write small programs that ran on the GPU for every vertex and every pixel. The GPU stopped being a fixed rendering appliance and became a programmable parallel processor aimed at graphics. That is the era of Halo — the original Xbox had a custom Nvidia GPU with programmable shaders, and Halo used them for water, lighting, bump mapping, and effects that no fixed-function hardware could have produced.
─── ◆ ───
The Pattern
If you step back and look at the full arc, a clear pattern repeats itself. Hardwired logic with no separation between game and hardware. Then a CPU with minimal display hardware, brute-forcing the rendering in real time. Then a more capable fixed-function graphics chip handling the drawing while the CPU handles logic. Then the CPU doing everything again on PC because there was no graphics chip worth mentioning. Then a fixed-function GPU re-introduced to break through the performance wall. Then that GPU becoming programmable so it could handle novel rendering techniques instead of just the ones it was wired for. Then shaders becoming general-purpose compute. Then specialized tensor cores showing up inside the GPU for machine learning workloads — specialized hardware inside specialized hardware.
The cycle is: general-purpose hits a wall, specialized hardware breaks through it, that specialized hardware gradually becomes more programmable and general, until the next wall appears and the cycle repeats. The "engine" concept just migrates up the stack as the hardware takes on more responsibility. When the hardware was the game, there was no engine. When the CPU did everything, the engine was the software renderer. When the GPU took over rendering, the engine became the orchestration layer managing what the CPU and GPU each do.
I watched this entire progression happen in real time over the course of my life. I have an original Atari in a box ten feet from where I am sitting right now, stacked in a pile with a Virtual Boy, a SNES, a Super Scope 6, and a Genesis. I watched every graphics card generation from the Voodoo forward. In 1997 I was playing Ultima IX and it required that card to even run — for reasons that are completely obvious now. And to run it on modern hardware today you still need a Glide wrapper because the game was built for fixed-function hardware that no longer exists.
─── ◆ ───
The Shader Model for Thinking
Here is where it gets personal. I realized I followed the exact same evolutionary path in my own head.
I started with fixed-function specialization. Machining was its own domain. Lapidary was its own domain. Guitar building, audio production, hardware repair, computing — each one was a dedicated chip that did one job. I learned each one as its own separate thing with its own rules, materials, and techniques.
But over time I started noticing that the operations transfer even when the materials change. Tolerances in machining and tolerances in lapidary are the same concept on different substrates. Signal flow in audio and signal flow in electronics and data flow in software are the same structural pattern. I stopped learning domains and started extracting the underlying operations. And once I had those, I could apply them to anything new by swapping in the material properties.
That is the programmable shader model. A fixed-function pipeline says "I do this specific thing to this specific input." A programmable pipeline says "give me the input description and the constraints and I will write the program on the fly." I generalized myself from hardwired circuits into a programmable processor. The domains are just texture data. My reasoning is the shader code. And I write a new shader for every new problem because I learned the instruction set, not just specific programs.
The path dependency matters here. I could not have jumped straight to this. Nobody becomes a general-purpose systems thinker from scratch. I had to do the machining to internalize what precision means at a physical level. I had to build the guitar to understand how properties emerge from material choices and geometry. I had to do the audio work to internalize signal-to-noise as a universal concept. Each domain was a training run that burned a deeper pattern into my reasoning. The general model emerged from the specific ones, exactly the way programmable shaders only became possible because GPU architects spent years building fixed-function stages and understood what operations were fundamental enough to be worth making programmable.
─── ◆ ───
The Universal Principle
Once I had the generalized model, something clicked that I was not expecting. I noticed that every system I have ever worked with follows the same fundamental rule.
You are controlling the rise of energy within a system over time. You want to put maximum energy through the system as fast as you can. And thermal is the limit. That is the wall. Nothing gets an exemption from thermodynamics.
A CPU dies because the silicon hits junction temperature before the heatsink can pull the heat away. An engine throws a rod because combustion pressure exceeds what the material can handle at that cycle rate. A thin piece of steel burns through under a weld because the arc deposits energy faster than the surrounding metal can conduct it away. A speaker blows because the voice coil accumulates thermal energy faster than it can radiate. A circuit trace burns because current density exceeds what the copper cross-section can carry.
Every single one of these is the same equation. Energy in per unit time versus the system's ability to absorb, convert, and dissipate. The maximum useful work you can extract from any system is bounded by how fast you can remove the waste heat. An engine, a CPU, a weld, a speaker — they are all governed by the same thermodynamic reality. Chemical energy to mechanical work and waste heat. Electrical energy to computational work and waste heat. Thermal energy into a joint and waste heat into the surrounding material. The useful work is what you are after and the heat is the byproduct, and the rate at which you can remove it is the hard ceiling on performance.
From here the entire job of engineering reduces to one sentence: give me the specs of the system and I will tune it to the edge of the envelope. Tell me the material limits, the cooling capacity, the thermal ceiling, and I will push the controllable variables to the boundary defined by those constraints. That process is the same whether I am overclocking a CPU, tuning an engine, dialing in a weld, or setting up a signal chain. The recipe for maximum performance is always the same — push the energy and speed to the limits of what the system can safely handle.
─── ◆ ───
Blueprints and the Gatekeeping Problem
This generalized thinking style also explains why visual programming works for me and text code does not. Unreal Engine's Blueprint system strips the syntax layer out completely and gives you the system diagram directly. Nodes are operations. Wires are energy flow. You are not writing text that describes logic to a compiler — you are looking at the operations and connecting them. It is a schematic, and I already knew how to read schematics from hardware, wiring, and audio signal flow. Blueprints did not teach me a new skill. They gave me a coding interface that matched the way I already think.
My error profile in Blueprints proves the point. I do not get syntax errors because there is no syntax. What I get is a misrouted wire or a missing logical step — the exact equivalent of wiring a circuit wrong or forgetting a stage in a signal chain. Those are system errors, not language errors.
I can review text code for logical correctness in any language without knowing that language because I am not parsing syntax. I am tracing the logic. What does this function take in, what does it do with it, what comes out, does that make sense. That is the same process as looking at an engine and asking whether this intake path makes sense for the airflow this combustor needs. The language is irrelevant. The logic is the system. But I cannot troubleshoot a misplaced comma or a syntax violation because that is not my processor type.
And this is where the gatekeeping gets ugly. When Blueprints launched, Epic had an awkward time with the terminology. They understood that visual scripters were doing real programming — building functional systems with logic, state management, data flow, and optimization. But they could not quite call it programming on paper because the traditional definition requires writing text code. The community split over it. People who made bad projects in Blueprints were used as evidence that the tool itself was bad, as if nobody ever wrote terrible text code.
The same thing is happening now with AI-assisted development. Some people use AI tools without understanding the logic underneath and produce garbage. That garbage is then used to argue that the method is fundamentally flawed. But nobody applies that standard in reverse. Nobody walks into a welding shop, watches a programmer fail to lay a bead, and concludes that welding is a fake skill. The tool did not fail. The person using it did not understand the system they were building in.
The real issue is that the programming profession built part of its identity around the difficulty of the notation. The syntax is the barrier to entry, and that barrier is what makes the credential feel valuable. If you let people in who can do the logic but skip the syntax, it threatens people whose professional identity depends on being the ones who can translate intent into notation. The pushback was never really about capability. It was about protecting the moat.
─── ◆ ───
The Takeaway
There is a way of thinking where you stop learning systems as isolated domains and start seeing the underlying operations that every system shares. It takes years to get there because you need the raw data from enough different domains before the common thread becomes visible. You cannot force it. You need the dataset.
But once it clicks, you can look at any system — mechanical, electrical, computational, organizational — and see the same structural pattern: energy in, work out, waste heat managed, performance tuned to the edge of the thermal envelope. The materials change. The constraints change. The recipe does not.
I did not learn this from a textbook. I learned it by burning a piece of metal and paying attention.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
|
|
|
.png "Photonamus Industries Forums")
![[Image: maduro-disrespect.jpg]](https://photonamus.com/images/photonamus/maduro-disrespect.jpg)
