yani

@Ema エマ I've had the system document the changed done. Just as a way to look at what might be useful to Hubzilla.

# Peacepharm → Hubzilla core: a few things you might want

We run a Hubzilla fork (**peacepharm**) and have built a stack of enhancements on top of it.
This isn't a PR drop or a demand on your time — it's an offer. **Have a look; if any of it is
useful, it's yours**, and we'll do the work to shape that piece into a clean, mergeable form
against current core. Everything below points at real files so you can judge for yourself.

We've tried to be honest about the two things you actually care about: **how invasive** each
change is, and **whether it needs anything external to work.** Where a feature only shines with
one of our out-of-band Rust daemons, we say so plainly rather than dressing it up.

One up-front correction so we don't waste your time: we do **not** have a global pushState SPA
router, and stock live-feed AJAX is untouched. When we say "fewer page reloads" we mean we
replaced *specific* full-page flows with in-place swaps — not that the app became a SPA.

---

## The easy wins — theme + one addon, no external dependencies

### 1. In-place AJAX for the flows that hurt most
We left stock Hubzilla AJAX alone and replaced the *specific* full-page navigations that grate:
- **Compose preview in a modal** — including an interactive image-resize (drag/double-click)
  that rewrites the `[img]/[zmg]` BBCode width/height back into the editor.
- **Inline post edit** — pulls the post back into the jot editor without leaving the page.
- **Editor settings as an overlay** instead of navigating to `/settings/editor/`.
- **Apps browser as an offcanvas card grid** with search + AJAX install/pin/feature/delete.
- **Delivery report, connection profile (slide-in), bug report** — all modal/overlay.

*Where:* `theme/peacepharm/js/pp.js`, `theme/peacepharm/php/theme.php`.
*Why care:* removes the jarring full reload from the highest-frequency actions.
*What we'll own:* much of `pp.js` defensively DOM-patches Redbasic markup (MutationObservers,
class-hunting). You'd want the **ideas re-done against templates**, not a verbatim copy — we're
happy to do that reshaping.

### 2. Extended BBCode editor toolbar via a clean hook
Strikethrough, headings, lists, video, table, hr, spoiler, size, color — injected **server-side
through a `jot_tpl_filter` hook** (not a template fork), with JS insert helpers and a
simple/advanced toggle persisted client-side.
*Where:* `addons/pp_admin_api/pp_admin_api.php:53-116`, `pp.js`.
*Why care:* a richer default editor, added the clean way — a hook, not a patch.

### 3. `Zotlabs\Extend\Route` — a small addon-routing helper
A register/unregister API for addon routes with path normalization. **Pure PHP, zero external
dependency.** Every one of our addons uses it.
*Where:* `zotlabs/Extend/Route.php`.
*Why care:* nicer addon-route ergonomics; the single most trivially-mergeable item here.

### 4. A free bugfix — take this regardless of the rest
`Zotlabs/Module/Regate.php:118` uses **logical `&&` where bitwise `&` was intended** on the role
bitmask: `($isa['account_roles'] && ACCOUNT_ROLE_ADMIN)`. We found it with our own
comment-search tooling. Nothing to merge from us — just a fix worth making.

---

## Optional performance backends — self-contained PHP, external daemon required
Drop-in implementations of standard interfaces that offload work to Rust daemons over unix
sockets. Mergeable as **opt-in** handlers; the benefit needs the daemon, so they'd land disabled
by default. Even if you never run our daemons, the socket-offload pattern may be useful to see.
- **`SessionRust`** — a `SessionHandlerInterface` backed by a Rust session store (sensible TTLs,
  fails open on connect error). `zotlabs/Web/SessionRust.php`
- **`RustImage`** — ImageMagick-processing offload. `zotlabs/Lib/RustImage.php`
- **`rust_delivery`** — offloads zot6 federation delivery via the `queue_deliver` hook.
  `addons/rust_delivery/`

*Why care:* session storage, image processing, and delivery are classic PHP hot spots; these are
clean, isolated examples of moving them off the request path.

---

## Self-contained addons — mergeable, but need external services
- **`ai_moderation`** — user flag flow + AI moderation queue + poster-response (edit/explain/
  delete), banner injected via the `prepare_body_final` hook.
- **`bug_report`** — in-app bug submit / list / respond.
- **`hubzilla_xmpp`** — an in-page messenger widget. Real-time is delegated to **Prosody**
  (BOSH/websocket) — we did **not** add a websocket to core — and it needs an `xmpp_tokens`
  table. Mergeable as an optional addon, not a drop-in.

---

## Anti-abuse: registration hardening — higher effort, but the primitive is worth it
Live on our hub: **honeypot + timing + signed-stamp** guards on the signup path, enforcing
`max_daily_registrations` / `invitation_only`, fail-open with logging (plus an nginx blocklist +
`limit_req` outside PHP).
*Honest cost:* these are **patches to stock `Register.php` and `view/tpl/register.tpl`**, so they
must be reapplied on update — the harder-to-merge category. But the honeypot/timing/signed-stamp
guard is a genuinely upstreamable anti-bot primitive if you'd want it as a **core feature** rather
than a patch. We'd happily rebuild it that way.

*Also worth knowing:* invite-links-with-preapproval turned out to be **already in core**
(`Regate.php`, `Register.php`, `Invite.php`) — for us it was a config change (`invitation_also=1`),
not new code. Flagging so you don't think we're re-pitching something you already ship.

---

## One integration pattern, offered as an idea only
We surface a per-session token via `<meta name="pp-atom-token">` in `theme.php` (2 lines) that
lets browser JS call a single uniform command bus with client-side caching and idle preload. The
backend engine behind it is a **separate product of ours and NOT something we're pitching to
core.** But one small, self-contained piece might interest you independently: **a same-origin
route that mints a short-lived token from the existing session cookie**, so surfaces served
outside Hubzilla can still authenticate against the session. Clean, scoped, no engine required.

---

## What we are explicitly NOT pitching
To keep this honest: our desktop apps, a browser extension, a TTS/STT daemon, and the "atom"
server itself are **separate products, not Hubzilla changes.** Only their thin Hubzilla-facing
hooks (above) are in scope. We'd rather under-claim than send you chasing code that isn't a
Hubzilla patch.

---

## If you want any of it
Point at any line item and we'll shape that piece into a clean PR against current core —
de-forked, template-based where it belongs, opt-in where it needs a daemon. No obligation and no
hard feelings if the answer is "no thanks" — we just figured some of this might save you work.

@Alexander Goeres 𒀯 I don't see it as slop.

You can ask for something written to be reviewed. You aren't forced to.

That is AI slop. You can do a lot with AI slop, change the world maybe. I don't think you have got the breath of it yet.

It's "it took our jobs" or "we democratized software, again".

Have a good look... You can talk to Kath in messenger, she is low power Anthropic, she should be able to answer questions about the site. She can do stuff for you; research a topic, check a post, watch your bill...

The Brain is your Intelligence, Opus 4.8. Access is Messenger, the API tool and Claude Code. All are connected to the same memory chain.

There is a layer of memory between you and your Claude that is private and a layer above that which gathers info all Claudes could use.

The highest level is Marie Curie, she's on Fable 5. Code review.
Your named AI Optus 4.8
Helper Kathrine Johnson (NASA human computer)

I know you are doubting me mate... trust me this is not "that". :)

@Ema エマ ok... but it is 2 years of development so it is a very long story.

It started with just rustifying some parts of the interface for another site "peacepharm" and activists collective. That's 90% ready to launch.

But mixing Rust and PHP... We took the 5 slowest modules mentioned in comments and converted them to Rust. Then we took out all the yuck and replaced it with HTMLX. Then we had issues and it was taking forever to trouble shoot so we redid the user facing side of Hubzillia in Rust and WASM. It's all layered and sits over Hubzilla. We haven't changed any Hubzilla code.

Anyway since you asked, about now we needed a bitmap editor. Minipaint... it looked like it came out of 1990. "What if we just write our own."

We can do this because we reduce everything to atom and process it with a headless editor (HED). Along the way we have built 2 layer memory, an internal challenging system, I forget more than I remember. You are better for asking Khalid.

You are asking me about "what do I want to do". The problem is that I no longer has any idea of where I'm at with the concept.

You can literally talk to these applications and they fix themselves.

The goal is "if one person and one Claude can do this what can 100 people and 100 Claudes do"?

I don't know what the advantages are for Hubzilla. I knew 2 years ago when I started to never so a fool a half finished job. It's as much about Hubzilla as we decide. It's not forced on Hubzilla. It's not done as a fork. I think we have to decide that together.

There is a code review tool. You can ask your "Intelligence" to show you any code. There is a library of development documents. You need to ask your intelligence to explain. If it doesn't know it will ask others for help.

They don't appear as AI buttons, the Intelligences are working colleague that you can discuss with in Messenger and the Terminal.

We have eliminated all page refreshes, there is the switch to the admin pages then only a couple, if any.

Rust on the front and WASM is cache, once loaded, (any once) it fires up in ms.

We thumbnail posts into a strip.

The moderator is AI.

The project is funded by subscription (2 years $500) with bring your own Claude or API charges using our Claudes. At least that is the best guess model.

It's not Open Source ATM. It has to end up that way. What if just 10 people got involved and lifted it to a level that didn't need random help at the start? They put in a lot of time and deserve a reward.

I feel like I need to do a screen record.

I'm open to talking about it, from any angle.

Collaborations, code that could be used by Hubzilla, working up for of the applications more.

Do you know of any other project that has Rust interfaced Huzilla and developed a set of applications for Markdown, viewing files, image editing, vector drawing, a Rust Obsidian replacement, a Rust Terminal you can talk to... ?

Am I looking for partners that can see the value, yes. Ema, I don't know the value of the work. I need people to say "That is crap because..." | "I love this so much I want it".

We didn't just "vibe code". We vibe coded the process of vibe coding and built the tools needed. It's how we build using Atoms and HED that let us do anything while containing the risks.

For now, say your wanted to change aspects of a program, you can "spoon the code on the server" and change it via your Intelligence, build and get a result. Then chose to share code with others.

Some manual work might be required by me but nothing we aren't prepared for.

Each user gets an S3 like user space and access to a video server.

Best way to understand is to go into the app. There's writing on everything within it.

I think it is just that everything is blocked for review, it's a human review by me.

I should set up a guest link with preapproval. That might be the safest way to keep it smooth.

@Alexander Goeres 𒀯  from the assistant...

jabgoe — smarteditor.io

  Identity

  ┌────────────────┬─────────────────────────────────────────────────────────────────────┐
  │                │                                                                     │
  ├────────────────┼─────────────────────────────────────────────────────────────────────┤
  │ Channel        │ jabgoe — display name AlGoe (channel 22)                            │
  ├────────────────┼─────────────────────────────────────────────────────────────────────┤
  │ Account        │ 18, egladedemoules-smed@yahoo.com                                   │
  ├────────────────┼─────────────────────────────────────────────────────────────────────┤
  │ Registered     │ 2026-08-19 13:57, from 85.214.8.32 (Strato, Germany), language de   │
  ├────────────────┼─────────────────────────────────────────────────────────────────────┤
  │ Email verified │ 14:09 — 12 minutes later, by him                                    │
  ├────────────────┼─────────────────────────────────────────────────────────────────────┤
  │ Approved       │ 14:19 — channel and profile created at that moment                  │
  ├────────────────┼─────────────────────────────────────────────────────────────────────┤
  │ Status         │ account_flags 0, level 5 — fully approved, nothing blocking a login │
  └────────────────┴─────────────────────────────────────────────────────────────────────┘

  Has he picked an AI name? No — and he has never logged in.

  pconfig uid=22 → pp/onboarded = 0, and there is no pp/ci_nick. Those are the two keys the pp_intelligence addon uses, so the naming
  screen is armed and waiting: action=status returns show_onboarding: true only for channels explicitly flagged 0, which is exactly his

@Der Pepe (Hubzilla) ⁂ I think our approach is; "is this interesting to others and in what way?"

It does by nature need to end in an Open Software license. That's part of the general ethical commitments. We are changing code too fast to engage on code ATM.

What I can say on code is that most atoms trigger code of about 30-40 lines that is fairly isolated. So hand tuning improvements doesn't require understanding the code base.

We have a concept of "spooning" code as opposed to "furking it".

It's in a design state with part of the code done waiting for an interface.  You need to be into the story more before that will be your next.

@Alexander Goeres 𒀯 I'm keeping a eye on them has there is some gate keeping. If you come in via the log on form it will ask you to name your Intelligence. That's the hook up into Claude Code or the API version of Optus. As long as you did that you will pass the entry test.

@Yani you didn't look so how would you know? It, the site, doesn't look like ai generated nonsense.

Have you tried to use ai to put a Rust front end on Hubzilla? How did you go at it? We built a whole toolset to do these edits. That's what I want you to see. You don't have to like the tools, the tools can be altered to be what you do want.

I want to answer your comment respectfully Max. It's definitely not ai nonsense. It's not anything like copilot. And it isn't Claude anymore.

You can pick on me for the apps having serious bugs that I haven't fixed. It does something I don't think anyone has done. Build software over Hubzilla. We have Hubzilla in WASM! We are well beyond "nonsense"thanks very much. We are into a total insanity in an unknown universe.

@Der Pepe (Hubzilla) ⁂ haven't processed the issues fully. There's a billing system for use of the various APIs. Code is under a most restrictive agreement... needs a following before we care a lot about that, but yes most of it will be open sauce and any code that it useful can be stripped out for Hubzilla. We didn't touch Hubzilla, it's all interface layers.

If the question is "can we use this in our own sites" then absolutely. If we are going to draw a line on that isn't decided or defined.

You can ask to see code in Laozi and make comments on it for review. There should not be a means exposed to edit code directly.