PAL v1.2 released - now with support for character events, attaching and detaching foreign windows

Hey everyone,

PAL (Prime Abstraction Layer) — a thin, explicit, low-overhead abstraction over native OS APIs and graphics APIs. Originally named as Platform Abstraction Layer, PAL has evolved into Prime Abstraction Layer — the first and most direct layer between your engine or software and the operating system.

I've just released v1.2.0 and below are the new improvements and features.

# Whats New

Added palGetInstance() to retrieve the native display or instance handle.
Added palAttachWindow() for attaching foreign windows to PAL.
Added palDetachWindow() for detaching foreign windows from PAL.
Added PAL_EVENT_KEYCHAR to PalEventType enum.
Added documentation for event bits(payload) layout.
Added multi-threaded OpenGL example: demonstrating Multi-Threaded OpenGL Rendering.
Added attaching and detach foreign windows example.
Added key character example.

see CHANGELOG.

Binaries for Windows and Linux with source code has been added in the release section.

Contributions are welcome!

https://github.com/nichcode/PAL

https://redd.it/1ombs3n
@r_opensource

File transfer over internet without storing in server or creating account
https://github.com/tonyantony300/alt-sendme

https://redd.it/1ombrdw
@r_opensource

Bye Bye Microsoft Office at International Criminal Court
https://peakd.com/news/@detlev/bye-bye-microsoft-office-at-international-criminal-court

https://redd.it/1omejbg
@r_opensource

So I made a Full-stack coding framework at 16 years old called ScrollForge: Causal Graph Programming which unifies state, logic, and style in one causal graph.

Hello everyone! So basically I had this idea where the frontend, backend, state, logic etc etc act as nodes within a causal graph, so I went ahead and made a framework on it! Basically it has three engines to be precise with many functions, it took me a longg time to make!

Below is a modest briefing about this framework, however, I must exclaim this is not everything, not even close. If you'd like to see everything, kindly go to the github repo and find the complete guide md to see all of its functions, there are even code snippits in that!

Also if you don't wanna go through the hassle, just go to your root directory and type

npm install scrollforge

Also, I'd love some critique on this ;D

# TL;DR

Paradigm: Causal Graph Programming (CGP) — you wire functions, not components; the framework auto-detects what each function needs and “snaps” it into a single causal graph (UI ⇄ logic ⇄ effects ⇄ style ⇄ backend).
Three engines:
ScrollMesh → component/templating via context auto-wiring (unlimited functions, zero manual wiring).
ScrollScript → universal signal store (client + server) with actions, watchers, derived signals, time travel.
ScrollWeave → logic-reactive styling (state/logic drives CSS & animations at runtime).
Why now: less boilerplate, fewer classes/hooks/providers, more causality visibility.
Showcase: real-time chat app in < 500 lines (HTML + JS + a tiny server).
Use cases: dashboards, real-time apps, design systems that react to logic, compact full-stack prototypes.
One-liner: ScrollForge – Causal Graph Programming: unify state, logic, style, and backend into one reactive graph.

# What is “Causal Graph Programming”?

The short version:
Instead of pushing data through props and bouncing events back through callbacks (typical UI frameworks), CGP lets you register as many functions as you want. Each function declares its intent implicitly by its signature (parameters), and the engine auto-provides matching contexts:

1. ({ ...stateProps }) => ui → UI renderer (gets state)
2. (events, state) => { ... } → event logic
3. (state, weave) => { ... } → styling/animation driven by state
4. (state, effects) => { ... } → reactive effects
5. () => ({ ... }) → initial state provider (…and several more contexts, all optional.)

Order doesn’t matter. Wiring doesn’t exist. The framework assembles a causal graph out of your functions and keeps it live.

\*

## Why this is different?

No props drilling, no provider pyramids, no manual event buses.
UI, logic, effects, and styles coordinate through shared, reactive signals (ScrollScript) and auto-wired contexts (ScrollMesh).
Style is not static: ScrollWeave treats CSS as a live system, not a file.

\*

# The three engines (in one project)

**

# 1) ScrollMesh — recursive component assembly (auto-wiring):

Write components by passing functions. The engine reads signatures and provides what you need.

import { HTMLScrollMesh } from 'scrollforge/dist/mesh-full.browser.js';

const Counter = HTMLScrollMesh(
// UI (gets state via destructuring)
({ count }) => <button class="btn">Count: ${count}</button>,

// Logic (gets events + state)
(events, state) => {
events.on('click', '.btn', () => state.count++);
},

// Initial state
() => ({ count: 0 })
);

Counter.mount('#app');


# 2) ScrollScript — universal data flow (signals, actions, derived):

Client and server share the same API. Signals update; watchers react; derived signals memoize computed values.

// Create global signals
app.Script.signal('messages', );
app.Script.signal('username', '');
app.Script.watch('messages', (msgs) => console.log('Count:', msgs.length));


# 3) ScrollWeave — logic-reactive styling

Let state and logic shape style at runtime.

(state, weave) => {
weave.when('.status',

state.online,
{ background: 'rgba(76, 175, 80, .2)' },
{ background: 'rgba(244, 67, 54, .2)' }
);

// Micro-interaction
weave.spring('.btn', { transform: 'scale(1.0)' }, { stiffness: 200, damping: 20 });
};


# The <500-line demo: real-time chat

Using this paradigm, we made a fully working chatapp in under 500 lines of code (present in the github repo at the end).

# ScrollMesh Context Auto-Wiring - Deep Dive

The Revolutionary Breakthrough

ScrollMesh Context is the most powerful feature in ScrollForge. It allows you to pass UNLIMITED functions that automatically detect what they need and connect themselves.

How It Works

import { HTMLScrollMesh } from 'scrollforge/mesh';

const component = HTMLScrollMesh(
function1,
function2,
function3,
// ... add as many as you want!
);


The framework:

1. Reads each function's signature (parameters)
2. Detects what contexts each function needs
3. Automatically provides those contexts
4. Wires everything together
5. NO manual configuration required! ✨

# The 8 Available Contexts:

Every function can request any of these contexts by adding them as parameters:

1. state - Reactive State Proxy
Get it by: Adding state as parameter
What you can do:

(state) => {
// READ
const count = state.count;
const name = state.user.name;

// WRITE (triggers re-render!)
state.count++;
state.user.name = 'Jane';

// Deep updates work
state.user.profile.settings.theme = 'dark';

// Arrays
state.items.push(newItem);
state.items = ...state.items, newItem;
}


2. events - Event System
Get it by: Adding events as parameter
What you can do:

(events, state) => {
// Listen to DOM events
events.on('click', '.button', (e) => {
state.count++;
});

events.on('input', '.search', (e) => {
state.query = e.target.value;
});

// Custom events
events.emit('customEvent', { data: 'value' });

events.on('customEvent', (data) => {
console.log('Event:', data);
});

// Remove listener
events.off('click', '.button', handler);
}


3. effects - Side Effects
Get it by: Adding effects as parameter
What you can do:

(state, effects) => {
// Watch state changes
effects.when('count', (count) => {
console.log('Count changed:', count);
document.noscript = Count: ${count};
});

// Watch with old value
effects.when('status', (newStatus, oldStatus) => {
console.log(${oldStatus} → ${newStatus});
});

// Run once on mount
effects.once('mounted', () => {
console.log('Component mounted!');
});

// Async effects
effects.when('userId', async (userId) => {
const user = await fetchUser(userId);
state.user = user;
});
}


4. weave - Styling (ScrollWeave)
Get it by: Adding weave as parameter
What you can do:

(state, weave) => {
// Apply styles
weave.apply('.element', {
background: 'blue',
padding: '20px'
});

// Conditional
weave.when('.button',
state.isActive,
{ background: 'green' },
{ background: 'gray' }
);

// Animations
weave.fadeIn('.modal', 300);
weave.spring('.card', { transform: 'scale(1)' });
}


5. api - API Calls
Get it by: Adding api as parameter
What you can do:

async (state, api) => {
// Fetch when signal changes
api.when('userId', async (userId) => {
const response = await api.fetch(/api/users/${userId});
const user = await response.json();
state.user = user;
});

// Manual fetch
const response = await api.fetch('/api/data');
const data = await response.json();
state.data = data;
}


6. storage - Persistence
Get it by: Adding storage as

parameter
What you can do:

(state, storage) => {
// Save
storage.persist('settings', state.settings);

// Load (async)
const saved = await storage.load('settings');
if (saved) state.settings = saved;

// Remove
storage.remove('settings');
}


WARNING: storage.load() is async - don't use in state function for initial load!

() => ({
todos: JSON.parse(localStorage.getItem('todos') || '') // Sync!
}),

(state, effects) => {
effects.when('todos', (todos) => {
localStorage.setItem('todos', JSON.stringify(todos)); // Save
});
}


7. validate - Validation
Get it by: Adding validate as parameter
What you can do:

(validate) => {
validate.rule('email',
(value) => /^^\s@+@^\s@+\.^\s@+$/.test(value),
'Invalid email format'
);

validate.rule('age',
(value) => value >= 18,
'Must be 18 or older'
);
}


8. analytics - Analytics Tracking
Get it by: Adding analytics as parameter
What you can do:

(state, analytics) => {
analytics.track('buttonClicked', () => state.clickCount);

analytics.track('pageView', () => ({
page: state.currentPage,
user: state.username
}));
}


# Auto-Detection Rules

The framework detects function type by its signature:

Signature Detected As Gets
({ count }) => ... UI Function State (destructured)
(state) => ... Logic/Effect State proxy
(events) => ... Logic Events
(events, state) => ... Logic Events + State
(state, weave) => ... Styling State + Weave
(state, effects) => ... Effects State + Effects
(state, api) => ... API State + API
() => ({ ... }) State Provider Nothing (returns state)
(state, events, weave, effects, api, storage, validate, analytics) => ... All Contexts All 8!


# State Function Special Rules

Must have ZERO parameters and return object:

// CORRECT
() => ({
count: 0,
user: { name: 'John' }
})

// WRONG - has parameters
(someParam) => ({
count: 0
})

// WRONG - doesn't return object
() => {
const count = 0;
// Missing return!
}


Can include special properties:

() => ({
// Regular state
count: 0,
email: '',

// Computed properties (auto-update!)
computed: {
doubleCount: (state) => state.count 2
},

// Selectors (memoized)
selectors: {
evenCount: (state) => state.count % 2 === 0
},

// Middleware (intercept changes)
middleware: {
count: (oldValue, newValue) => {
return newValue < 0 ? 0 : newValue; // Prevent negative
}
},

// Validation (runtime checks)
validate: {
email: (value) => /^[^\s@]+@[^\s@]+/.test(value) || 'Invalid email'
},

// Options
immutable: true, // Freeze state
debug: {
logChanges: true,
breakOnChange: ['count']
}
})


# HTMLScrollMesh - Quick Reference

HTMLScrollMesh = ScrollMesh Context + HTML template strings

Basic Pattern:

import { HTMLScrollMesh } from 'scrollforge/mesh';

const App = HTMLScrollMesh(
// UI - Write HTML directly
({ count }) => `<button>${count}</button>`,

// Events
(events, state) => {
events.on('click', 'button', () => state.count++);
},

// State
() => ({ count: 0 })
);

App.mount('#app');


# All 8 Contexts Work Identically

HTMLScrollMesh has the SAME context auto-wiring as ScrollMesh:

(events, state) → Events + State
(state, weave) → State + ScrollWeave styling
(state, effects) → State + Side effects
(state, api) → State + API calls
(storage) → Storage context
(validate) → Validation
(analytics) → Analytics
() => ({ ... }) → State provider (zero params!)
Same rules. Same auto-detection. Just HTML instead of JS

So I made a Full-stack coding framework at 16 years old called ScrollForge: Causal Graph Programming which unifies state, logic, and style in one causal graph.

Hello everyone! So basically I had this idea where the frontend, backend, state, logic etc etc act as nodes within a causal graph, so I went ahead and made a framework on it! Basically it has three engines to be precise with many functions, it took me a longg time to make!

Below is a modest briefing about this framework, however, I must exclaim this is not everything, not even close. If you'd like to see everything, kindly go to the github repo and find the complete guide md to see all of its functions, there are even code snippits in that!

Also if you don't wanna go through the hassle, just go to your root directory and type

npm install scrollforge

Also, I'd love some critique on this ;D

# TL;DR

* Paradigm: Causal Graph Programming (CGP) — you wire functions, not components; the framework auto-detects what each function needs and “snaps” it into a single causal graph (UI ⇄ logic ⇄ effects ⇄ style ⇄ backend).
* Three engines:
* ScrollMesh → component/templating via context auto-wiring (unlimited functions, zero manual wiring).
* ScrollScript → universal signal store (client + server) with actions, watchers, derived signals, time travel.
* ScrollWeave → logic-reactive styling (state/logic drives CSS & animations at runtime).
* Why now: less boilerplate, fewer classes/hooks/providers, more causality visibility.
* Showcase: real-time chat app in < 500 lines (HTML + JS + a tiny server).
* Use cases: dashboards, real-time apps, design systems that react to logic, compact full-stack prototypes.
* One-liner: ScrollForge – Causal Graph Programming: unify state, logic, style, and backend into one reactive graph.

# What is “Causal Graph Programming”?

**The short version:**
Instead of pushing data through props and bouncing events back through callbacks (typical UI frameworks), CGP lets you register as many functions as you want. Each function declares its intent implicitly by its signature (parameters), and the engine auto-provides matching contexts:

1. ({ ...stateProps }) => ui → UI renderer (gets state)
2. (events, state) => { ... } → event logic
3. (state, weave) => { ... } → styling/animation driven by state
4. (state, effects) => { ... } → reactive effects
5. () => ({ ... }) → initial state provider *(…and several more contexts, all optional.)*

Order doesn’t matter. Wiring doesn’t exist. The framework assembles a causal graph out of your functions and keeps it live.

\*\*

**## Why this is different?**

* No props drilling, no provider pyramids, no manual event buses.
* UI, logic, effects, and styles coordinate through shared, reactive signals (ScrollScript) and auto-wired contexts (ScrollMesh).
* Style is not static: ScrollWeave treats CSS as a live system, not a file.

\*\*

# The three engines (in one project)

\*\*

# 1) ScrollMesh — recursive component assembly (auto-wiring):

Write components by passing functions. The engine reads signatures and provides what you need.

import { HTMLScrollMesh } from 'scrollforge/dist/mesh-full.browser.js';

const Counter = HTMLScrollMesh(
// UI (gets state via destructuring)
({ count }) => `<button class="btn">Count: ${count}</button>`,

// Logic (gets events + state)
(events, state) => {
events.on('click', '.btn', () => state.count++);
},

// Initial state
() => ({ count: 0 })
);

Counter.mount('#app');


# 2) ScrollScript — universal data flow (signals, actions, derived):

Client and server share the same API. Signals update; watchers react; derived signals memoize computed values.

// Create global signals
app.Script.signal('messages', []);
app.Script.signal('username', '');
app.Script.watch('messages', (msgs) => console.log('Count:', msgs.length));


# 3)** ScrollWeave **— logic-reactive styling

Let state and logic shape style at runtime.

(state, weave) => {
weave.when('.status',

state.online,
{ background: 'rgba(76, 175, 80, .2)' },
{ background: 'rgba(244, 67, 54, .2)' }
);

// Micro-interaction
weave.spring('.btn', { transform: 'scale(1.0)' }, { stiffness: 200, damping: 20 });
};


# **The <500-line demo: real-time chat

Using this paradigm, we made a fully working chatapp in under 500 lines of code (present in the github repo at the end).

# ScrollMesh Context Auto-Wiring - Deep Dive

**The Revolutionary Breakthrough**

ScrollMesh Context is the most powerful feature in ScrollForge. It allows you to pass UNLIMITED functions that automatically detect what they need and connect themselves.

**How It Works**

import { HTMLScrollMesh } from 'scrollforge/mesh';

const component = HTMLScrollMesh(
function1,
function2,
function3,
// ... add as many as you want!
);


**The framework:**

1. Reads each function's signature (parameters)
2. Detects what contexts each function needs
3. Automatically provides those contexts
4. Wires everything together
5. NO manual configuration required! ✨

# The 8 Available Contexts:

Every function can request any of these contexts by adding them as parameters:

**1. state - Reactive State Proxy**
Get it by: Adding state as parameter
What you can do:

(state) => {
// READ
const count = state.count;
const name = state.user.name;

// WRITE (triggers re-render!)
state.count++;
state.user.name = 'Jane';

// Deep updates work
state.user.profile.settings.theme = 'dark';

// Arrays
state.items.push(newItem);
state.items = [...state.items, newItem];
}


**2. events - Event System**
Get it by: Adding events as parameter
What you can do:

(events, state) => {
// Listen to DOM events
events.on('click', '.button', (e) => {
state.count++;
});

events.on('input', '.search', (e) => {
state.query = e.target.value;
});

// Custom events
events.emit('customEvent', { data: 'value' });

events.on('customEvent', (data) => {
console.log('Event:', data);
});

// Remove listener
events.off('click', '.button', handler);
}


**3. effects - Side Effects**
Get it by: Adding effects as parameter
What you can do:

(state, effects) => {
// Watch state changes
effects.when('count', (count) => {
console.log('Count changed:', count);
document.noscript = `Count: ${count}`;
});

// Watch with old value
effects.when('status', (newStatus, oldStatus) => {
console.log(`${oldStatus} → ${newStatus}`);
});

// Run once on mount
effects.once('mounted', () => {
console.log('Component mounted!');
});

// Async effects
effects.when('userId', async (userId) => {
const user = await fetchUser(userId);
state.user = user;
});
}


**4. weave - Styling (ScrollWeave)**
Get it by: Adding weave as parameter
What you can do:

(state, weave) => {
// Apply styles
weave.apply('.element', {
background: 'blue',
padding: '20px'
});

// Conditional
weave.when('.button',
state.isActive,
{ background: 'green' },
{ background: 'gray' }
);

// Animations
weave.fadeIn('.modal', 300);
weave.spring('.card', { transform: 'scale(1)' });
}


**5. api - API Calls**
Get it by: Adding api as parameter
What you can do:

async (state, api) => {
// Fetch when signal changes
api.when('userId', async (userId) => {
const response = await api.fetch(`/api/users/${userId}`);
const user = await response.json();
state.user = user;
});

// Manual fetch
const response = await api.fetch('/api/data');
const data = await response.json();
state.data = data;
}


**6. storage - Persistence**
Get it by: Adding storage as

parameter
What you can do:

(state, storage) => {
// Save
storage.persist('settings', state.settings);

// Load (async)
const saved = await storage.load('settings');
if (saved) state.settings = saved;

// Remove
storage.remove('settings');
}


*WARNING: storage.load() is async - don't use in state function for initial load!*

() => ({
todos: JSON.parse(localStorage.getItem('todos') || '[]') // Sync!
}),

(state, effects) => {
effects.when('todos', (todos) => {
localStorage.setItem('todos', JSON.stringify(todos)); // Save
});
}


**7. validate - Validation**
Get it by: Adding validate as parameter
What you can do:

(validate) => {
validate.rule('email',
(value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
'Invalid email format'
);

validate.rule('age',
(value) => value >= 18,
'Must be 18 or older'
);
}


**8. analytics - Analytics Tracking**
Get it by: Adding analytics as parameter
What you can do:

(state, analytics) => {
analytics.track('buttonClicked', () => state.clickCount);

analytics.track('pageView', () => ({
page: state.currentPage,
user: state.username
}));
}


# Auto-Detection Rules

The framework detects function type by its signature:

**Signature Detected As Gets**
({ count }) => ... UI Function State (destructured)
(state) => ... Logic/Effect State proxy
(events) => ... Logic Events
(events, state) => ... Logic Events + State
(state, weave) => ... Styling State + Weave
(state, effects) => ... Effects State + Effects
(state, api) => ... API State + API
() => ({ ... }) State Provider Nothing (returns state)
(state, events, weave, effects, api, storage, validate, analytics) => ... All Contexts All 8!


# State Function Special Rules

Must have ZERO parameters and return object:

// CORRECT
() => ({
count: 0,
user: { name: 'John' }
})

// WRONG - has parameters
(someParam) => ({
count: 0
})

// WRONG - doesn't return object
() => {
const count = 0;
// Missing return!
}


**Can include special properties:**

() => ({
// Regular state
count: 0,
email: '',

// Computed properties (auto-update!)
computed: {
doubleCount: (state) => state.count * 2
},

// Selectors (memoized)
selectors: {
evenCount: (state) => state.count % 2 === 0
},

// Middleware (intercept changes)
middleware: {
count: (oldValue, newValue) => {
return newValue < 0 ? 0 : newValue; // Prevent negative
}
},

// Validation (runtime checks)
validate: {
email: (value) => /^[^\s@]+@[^\s@]+/.test(value) || 'Invalid email'
},

// Options
immutable: true, // Freeze state
debug: {
logChanges: true,
breakOnChange: ['count']
}
})


# HTMLScrollMesh - Quick Reference

HTMLScrollMesh = ScrollMesh Context + HTML template strings

**Basic Pattern:**

import { HTMLScrollMesh } from 'scrollforge/mesh';

const App = HTMLScrollMesh(
// UI - Write HTML directly
({ count }) => `<button>${count}</button>`,

// Events
(events, state) => {
events.on('click', 'button', () => state.count++);
},

// State
() => ({ count: 0 })
);

App.mount('#app');


# All 8 Contexts Work Identically

HTMLScrollMesh has the SAME context auto-wiring as ScrollMesh:

* (events, state) → Events + State
* (state, weave) → State + ScrollWeave styling
* (state, effects) → State + Side effects
* (state, api) → State + API calls
* (storage) → Storage context
* (validate) → Validation
* (analytics) → Analytics
* () => ({ ... }) → State provider (zero params!)
* Same rules. Same auto-detection. Just HTML instead of JS

objects.

# HTML Features

({ items, isLoggedIn, user }) => `
<!-- Conditionals -->
${isLoggedIn ? `<p>Hello ${user.name}</p>` : `<p>Login</p>`}

<!-- Loops -->
<ul>
${items.map(i => `<li>${i.name}</li>`).join('')}
</ul>

<!-- Expressions -->
<p>Total: $${(price * quantity).toFixed(2)}</p>
`


**Key Difference from ScrollMesh Context:**

1. ScrollMesh HTMLScrollMesh
2. { tag: 'div', content: 'Hi' } <div>Hi</div>
3. JS Objects HTML Strings


# ** Using ScrollWeave with HTMLScrollMesh**

**The Pattern:**

HTMLScrollMesh(
// UI function
({ count }) => `<button class="my-btn">${count}</button>`,

// Weave function - gets (state, weave) automatically!
(state, weave) => {
// Apply reactive styles based on state
weave.when('.my-btn',
state.count > 10,
{ background: 'green', fontSize: '2rem' }, // If count > 10
{ background: 'blue', fontSize: '1rem' } // Else
);
},

// Other functions...
(events, state) => {
events.on('click', '.my-btn', () => state.count++);
},

() => ({ count: 0 })
);


**The framework automatically:**

1. Detects (state, weave) signature
2. Provides state proxy + ScrollWeave instance
3. Styles update when state changes
4. Zero manual wiring! ✨

# How It Works

HTMLScrollMesh(
// Function with (state, weave) parameters
(state, weave) => {
// Framework provides:
// - state: reactive component state
// - weave: ScrollWeave instance (app.Weave)

// Use state to drive styles
weave.apply('.element', {
color: state.isActive ? 'green' : 'gray',
fontSize: state.count > 5 ? '2rem' : '1rem'
});
}
);

// Framework auto-detects parameter names!


# Complete Example

const Counter = HTMLScrollMesh(
// UI
({ count, isHigh }) => `
<div class="counter">
<h1 class="display">${count}</h1>
<button class="increment">+</button>
<button class="decrement">-</button>
${isHigh ? `<p class="warning">⚠️ High count!</p>` : ''}
</div>
`,

// Weave - Reactive styling!
(state, weave) => {
// Style changes based on state
weave.when('.display',
state.count > 10,
{
color: 'green',
fontSize: '4rem',
fontWeight: 'bold'
},
{
color: 'blue',
fontSize: '2rem',
fontWeight: 'normal'
}
);

// Button styling
weave.when('.increment',
state.count >= 20,
{ background: '#ccc', cursor: 'not-allowed' },
{ background: '#4CAF50', cursor: 'pointer' }
);

// Animate warning
if (state.isHigh) {
weave.spring('.warning', {
opacity: 1,
transform: 'scale(1)'
});
}
},

// Events
(events, state) => {
events.on('click', '.increment', () => {
if (state.count < 20) state.count++;
});

events.on('click', '.decrement', () => {
if (state.count > 0) state.count--;
});
},

// State
() => ({
count: 0,

computed: {
isHigh: (state) => state.count > 15
}
})
);

Counter.mount('#app');


**State changes → Weave updates styles → UI reflects changes! ✨**

**Key Points**

1. Get weave context: Add weave as parameter after state
2. Signature: (state, weave) => { ... }
3. Framework provides: Your app's app.Weave instance automatically
4. Use state: Access component state to drive styles
5. Reactive: Styles update automatically when state changes

That's it! Just add weave parameter and you get reactive styling!

# Links:

*

[https://www.npmjs.com/package/scrollforge](https://www.npmjs.com/package/scrollforge)
* [www.infernusreal.com](http://www.infernusreal.com/) \-> Portfolio website

Thank you <3, also although I have tested all the features and examples I have shown and even used it to make many small samples, if you find any problems with it, kindly contact me through the number given in the portfolio website!

I am only 16 so hopefully I am not embarrassing myself here, I also just entered Nasa space apps challenge 2025 this year, you can find the link to that page here:

[https://www.spaceappschallenge.org/2025/find-a-team/perseverance5/](https://www.spaceappschallenge.org/2025/find-a-team/perseverance5/)


And yes I am flexing :>

https://redd.it/1omfnv8
@r_opensource

I live in the Arctic Circle and needed to train an AI Aurora detector, so I built picsort, a keyboard-driven app to sort thousands of images
https://picsort.coolapso.sh

https://redd.it/1omfte4
@r_opensource

bash_logger: A lightweight logging library that provides structured logging with multiple log levels, automatic rotation, and customizable output.
https://github.com/D4rth-C0d3r/bash_logger

https://redd.it/1omgmax
@r_opensource

NeuraSnip A Local Semantic Image Search Engine

NeuraSnip is a local AI-powered image search engine that lets you search your personal photo collection using natural language.

Think Google Photos search, but 100% private & offline no accounts, no cloud uploads, no subnoscriptions.

What It Does :

Semantic Search – “sunset on beach”, “cat sleeping”, etc.
Image-to-Image Search – find similar photos by example
Hybrid Search – text + image combo for precision
OCR Built-in – search text inside images (like receipts/screenshots)
Offline & Private – everything runs locally, no uploads
Fast – results in under 100ms after indexing


repo - https://github.com/Ayushkumar111/neurasnip



https://redd.it/1omjdwf
@r_opensource

Open Source UI font — Cal Sans UI
https://github.com/calcom/sans-ui

https://redd.it/1omkrb0
@r_opensource

GitHub - profullstack/qaai: QAai.dev -- AI-driven QA assistant
https://github.com/profullstack/qaai

https://redd.it/1omiju9
@r_opensource

SyncPit - Ephemeral shared whiteboards powered by Yjs
https://syncpit.live/

https://redd.it/1omn7un
@r_opensource

I made an Android app to manage my Docker containers on the go

Hello Everyone,
As a guy who likes to self host everything from side project backends to multiple arr's for media hosting, it has always bugged me that for checking logs, starting containers etc. I had to open my laptop and ssh into the server. And while solutions like sshing from termux exist, it's really hard to do on a phone's screen.

Docker manager solves that. Docker Manager lets you manage your containers, images, networks, and volumes — right from your phone. Do whatever you could possibly want on your server from your phone all with beautiful Material UI.

You can get it on play store here: https://play.google.com/store/apps/details?id=com.pavit.docker

The app is fully open-source — check it out here: https://github.com/theSoberSobber/Docker-Manager

Key Features
\- Add multiple servers with password or key-based SSH auth
\- Seamlessly switch between multiple servers
\- Manage containers — start, stop, restart, inspect, and view logs
\- Get a shell inside containers or on the host itself (/bin/bash, redis-cli, etc.)
\- Build or pull images from any registry, and rename/delete them easily
\- Manage networks and volumes — inspect, rename, and remove
\- View real-time server stats (CPU, memory, load averages)
\- Light/Dark/System theme support
\- Works over your phone’s own network stack (VPNs like Tailscale supported)

https://redd.it/1ompc2a
@r_opensource

self-hosted manga reader (based on mokuro, sentence mining, translation, grammar explanation), MIT License

Made a little wrapper NextJS 15 application around mokuro manga OCR.

To make it easier to read manga in Japanese.

Upon text highlight, you can translate the sentence, let LLM to explain the grammar, save sentence (with grammar) to flashcard that also has picture of related manga panel.

Nothing fancy, but for me it worked a bit better than just to use mokuro+yomitan extension.


Alpha version of the app, will have likely bugs, you can report the bugs in Discord:

https://discord.com/invite/afefVyfAkH

Manga reader github repo:

https://github.com/tristcoil/hanabira.org\_manga\_reader

Open-Source, MIT License.

Just build it with docker compose and run it. You will need to provide your manga mokuro OCR files separately (mokuro is just python library, takes 5 minutes to setup)

Mokuro github and instructions:
https://github.com/kha-white/mokuro

Tested to work well on Linux VM (Ubuntu), no tests have been done on Windows or Mac.

https://redd.it/1omn1s0
@r_opensource

An Open-Source Proof-of-Concept for the Yang–Mills Mass Gap (SU(3)) - Zer00logy / Zero-Ology

# Releasing the Zero Freeze Formula:

# An Open-Source Proof-of-Concept for the Yang–Mills Mass Gap (SU(3))

# TL;DR

We built a small, reproducible Python model that finds a real SU(3) mass gap —
a first-principles numerical proof-of-concept for one of the biggest unsolved problems in math and physics.

It runs locally.
It’s stable.
It’s open source.
It works.

\>>
Hey everyone -- this is a major open release from the same team behind Zer00logy and the symbolic cognition framework.

Today, we’re publishing something more physical — a working, open-source Python model that empirically demonstrates a nonzero mass gap in a compact SU(3) gauge system.

The Zero Freeze Hamiltonian Lattice Gauge Benchmark Suite (v2.2)
is a deterministic Python experiment built to test one of the hardest problems in mathematical physics:
The Yang–Mills Mass Gap Problem — one of the Clay Millennium Prize Problems.

It constructs a small lattice Hamiltonian for a real SU(3) gauge field, diagonalizes it using sparse linear algebra (scipy.sparse.linalg.lobpcg), and measures the energy difference between the first two eigenstates:

Δm=E1−E0>0\\Delta m = E_1 - E_0 > 0Δm=E1​−E0​>0

That’s the mass gap.
And yes — we found it.

How It Works

Builds a real SU(3) Hamiltonian from 3×3 Gell-Mann matrices.
Uses deterministic sparse diagonalization (no Monte Carlo noise).
Includes self-healing solver fallback for numerical stability.
Verifies physics conditions automatically:
Hermiticity
Eigenvalue normalization
Δvals stability
Mass gap persistence

All done on a CPU laptop — no GPU, no supercomputer.
The vacuum stayed stable.
The mass gap stayed positive.

Open Source Repository

GitHub: Zero-Ology/Zero\_Freeze\_Hamiltonian\_Lattice\_Gauge\_Benchmark\_Suite.py at main · haha8888haha8888/Zero-Ology
(mirrored with Zer00logy ecosystem)

Includes:

Full Python noscript -- Zero\_Freeze\_Hamiltonian\_Lattice\_Gauge\_Benchmark\_Suite.py
Eigenvalue logs from prototype runs
Annotated paper draft (plaintext + LaTeX)
Verification utilities for is_hermitian, solver diagnostics, and stability checks.

The mass gap problem defines why quantum fields in the strong force are confined.
A positive Δm means: the vacuum resists excitation.
Matter is bound.
Energy “freezes” into mass.

That’s why this model is called Zero Freeze —
it’s where zero isn’t empty… it’s frozen potential.

# Credits

Author: Stacey Szmy
Co-Authors: OpenAIChatGPT, Microsoft Copilot
Special Thanks: OpenAI, Meta, Microsoft, and the open science community.
License: Zero-Ology License 1.15

# Core Formula — The Zero Freeze Mass Gap Relation

Let HHH be the lattice Hamiltonian for a compact gauge group G=SU(3)G = SU(3)G=SU(3), acting on a finite 2D lattice of size LLL.

We compute its spectrum:

Then define the mass gap as:

where:

E0E\_0E0​ is the ground state energy (the vacuum),
E1E_1E1​ is the first excited energy (the lightest glueball or excitation).

# Existence Condition

For a confining quantum gauge field (such as SU(3)):

That means the energy spectrum is gapped, and the vacuum is stable.

# Lattice Limit Relation

In the continuum limit as the lattice spacing a→0a \\to 0a→0,

This mphysm_{\\text{phys}}mphys​ is the physical mass gap, the minimal excitation energy above the vacuum.

# Numerical Implementation (as in your Python suite)

Where:

UUU = SU(3) link operator (built from Gell-Mann matrices),
EEE = corresponding conjugate electric field operator,
α,β\\alpha, \\betaα,β are coupling constants normalized for each prototype mode,
ϵ\\epsilonϵ ≈ numerical tolerance (∼10⁻³–10⁻⁴ in tests).

# Observed Prototype Result (empirical validation)

|Lattice Size (L)|Δm (Observed)|Stability

An Open-Source Proof-of-Concept for the Yang–Mills Mass Gap (SU(3)) - Zer00logy / Zero-Ology

# Releasing the Zero Freeze Formula:

# An Open-Source Proof-of-Concept for the Yang–Mills Mass Gap (SU(3))

# TL;DR

We built a small, reproducible Python model that finds a **real SU(3) mass gap** —
a first-principles numerical proof-of-concept for one of the biggest unsolved problems in math and physics.

It runs locally.
It’s stable.
It’s open source.
It works.

\>>
Hey everyone -- this is a major open release from the same team behind Zer00logy and the symbolic cognition framework.

Today, we’re publishing something more physical — **a working, open-source Python model that empirically demonstrates a nonzero mass gap** in a compact SU(3) gauge system.

The **Zero Freeze Hamiltonian Lattice Gauge Benchmark Suite (v2.2)**
is a deterministic Python experiment built to test one of the hardest problems in mathematical physics:
**The Yang–Mills Mass Gap Problem** — one of the Clay Millennium Prize Problems.

It constructs a small lattice Hamiltonian for a real SU(3) gauge field, diagonalizes it using sparse linear algebra (`scipy.sparse.linalg.lobpcg`), and measures the energy difference between the first two eigenstates:

Δm=E1−E0>0\\Delta m = E\_1 - E\_0 > 0Δm=E1​−E0​>0

That’s the mass gap.
And yes — we found it.

How It Works

* Builds a **real SU(3) Hamiltonian** from 3×3 Gell-Mann matrices.
* Uses **deterministic sparse diagonalization** (no Monte Carlo noise).
* Includes **self-healing solver fallback** for numerical stability.
* Verifies physics conditions automatically:
* Hermiticity
* Eigenvalue normalization
* Δvals stability
* Mass gap persistence

All done on a **CPU laptop** — no GPU, no supercomputer.
The vacuum stayed stable.
The mass gap stayed positive.

Open Source Repository

**GitHub:** [Zero-Ology/Zero\_Freeze\_Hamiltonian\_Lattice\_Gauge\_Benchmark\_Suite.py at main · haha8888haha8888/Zero-Ology](https://github.com/haha8888haha8888/Zero-Ology/blob/main/Zero_Freeze_Hamiltonian_Lattice_Gauge_Benchmark_Suite.py)
*(mirrored with Zer00logy ecosystem)*

Includes:

* Full Python noscript -- Zero\_Freeze\_Hamiltonian\_Lattice\_Gauge\_Benchmark\_Suite.py
* Eigenvalue logs from prototype runs
* Annotated paper draft (plaintext + LaTeX)
* Verification utilities for `is_hermitian`, solver diagnostics, and stability checks.

The **mass gap problem** defines why quantum fields in the strong force are *confined*.
A positive Δm means: the vacuum resists excitation.
Matter is bound.
Energy “freezes” into mass.

That’s why this model is called **Zero Freeze** —
it’s where zero isn’t empty… it’s frozen potential.

# Credits

**Author:** Stacey Szmy
**Co-Authors:** OpenAIChatGPT, Microsoft Copilot
**Special Thanks:** OpenAI, Meta, Microsoft, and the open science community.
**License:** Zero-Ology License 1.15

# Core Formula — The Zero Freeze Mass Gap Relation

Let HHH be the lattice Hamiltonian for a compact gauge group G=SU(3)G = SU(3)G=SU(3), acting on a finite 2D lattice of size LLL.

We compute its spectrum:

Then define the mass gap as:

where:

* E0E\_0E0​ is the ground state energy (the vacuum),
* E1E\_1E1​ is the first excited energy (the lightest glueball or excitation).

# Existence Condition

For a confining quantum gauge field (such as SU(3)):

That means the energy spectrum is gapped, and the vacuum is stable.

# Lattice Limit Relation

In the continuum limit as the lattice spacing a→0a \\to 0a→0,

This mphysm\_{\\text{phys}}mphys​ is the physical mass gap, the minimal excitation energy above the vacuum.

# Numerical Implementation (as in your Python suite)

Where:

* UUU = SU(3) link operator (built from Gell-Mann matrices),
* EEE = corresponding conjugate electric field operator,
* α,β\\alpha, \\betaα,β are coupling constants normalized for each prototype mode,
* ϵ\\epsilonϵ ≈ numerical tolerance (∼10⁻³–10⁻⁴ in tests).

# Observed Prototype Result (empirical validation)

|Lattice Size (L)|Δm (Observed)|Stability