Hey everyone,

I wanted to share two open-source tools I built to make 3D modding for Paralives a lot faster: ParaForge and ParaReload.

Normally, testing custom items requires manually building mod folders and restarting the game every time you update a texture or tweak a mesh. These two tools let you export straight from Blender and view the changes live in-game.

ParaForge (Blender Addon)

A panel for Blender 4.2+ that checks your mesh against Paralives rules and exports ready-to-use mod packages.

• Runs a checklist (unit scale, transforms, origin placement, bounding box, triangle budget, UV maps)
• Automatically packs textures into the format the game reads
• Writes the FBX, PNGs, and setting files directly into your .mod folder in two clicks

GitHub: https://github.com/infinition/paraforge

ParaReload (In-Game BepInEx Plugin)

A plugin for Paralives that reloads your mod assets on the fly without closing the game.

• Open the cheat console (CTRL + SHIFT + C) and type reload
• Re-reads updated 3D models, textures, and setting files in real-time
• Automatically repairs mesh and material references so items placed on your lot stay in place without disappearing

GitHub: https://github.com/infinition/parareload

Workflow

1. Create your item in Blender.
2. Export with ParaForge.
3. Type reload in the Paralives cheat console.

Both projects are free and open source. Let me know if you try them out or have any feedback!

Hi,

I've been building this for a while and it's finally at a point where it might be useful to someone other than me.

Scriptorium is a markdown editor, ultra customizable, that reads and writes plain .md files in a folder you choose.No database, no sync service, no account. A subfolder is a section, a .md is a document. If you uninstall it tomorrow your writing is still just files sitting in a folder.

The part I actually built it for is the ideas panel beside the editor. When you're writing and a sentence turns up that doesn't belong where you are, it goes into a cloud next to the text instead of derailing the paragraph. Ideas are grouped into themes, one plain .md file per theme, and it's all drag and drop: reorder one inside its theme, drop it on another theme to move it there, or drag it into the document to insert it as a block exactly where you let go.

The rest of it:

• headings, lists, code, tables and LaTeX render live, and the line under your cursor flips back to raw markdown so you edit it like a text file
• snapshots per document, compare and restore before a big cut
• themes carrying their own fonts, backgrounds and icons, all stored inside the workspace folder, so copying that folder carries your whole setup to another machine
• fully offline, nothing is fetched from a CDN
• runs as a native window on Windows, macOS and Linux, or as a small local server you can open from a phone on the same network

Things I'd rather you hear from me than find out yourself:

• the macOS build isn't signed, I don't have an Apple developer account, so you have to run "xattr -cr /Applications/Scriptorium.app" once before it will open
• it's a Node server behind a native window, so it's not a tiny binary
• I'm basically the only person who has used it seriously, so expect rough edges in places I never walked through

Free, source on GitHub.

Site : https://infinition.github.io/scriptorium/ Github : https://github.com/infinition/scriptorium

Hi,

I've been building this for a while and it's finally at a point where it might be useful to someone other than me.

Scriptorium is a markdown editor, ultra customizable, that reads and writes plain .md files in a folder you choose. No database, no sync service, no account. A subfolder is a section, a .md is a document. If you uninstall it tomorrow your writing is still just files sitting in a folder.

The part I actually built it for is the ideas panel beside the editor. When you're writing and a sentence turns up that doesn't belong where you are, it goes into a cloud next to the text instead of derailing the paragraph. Ideas are grouped into themes, one plain .md file per theme, and it's all drag and drop: reorder one inside its theme, drop it on another theme to move it there, or drag it into the document to insert it as a block exactly where you let go.

The rest of it:

• headings, lists, code, tables and LaTeX render live, and the line under your cursor flips back to raw markdown so you edit it like a text file
• snapshots per document, compare and restore before a big cut
• themes carrying their own fonts, backgrounds and icons, all stored inside the workspace folder, so copying that folder carries your whole setup to another machine
• fully offline, nothing is fetched from a CDN
• runs as a native window on Windows, macOS and Linux, or as a small local server you can open from a phone on the same network

Things I'd rather you hear from me than find out yourself:

• the macOS build isn't signed, I don't have an Apple developer account, so you have to run "xattr -cr /Applications/Scriptorium.app" once before it will open
• it's a Node server behind a native window, so it's not a tiny binary
• I'm basically the only person who has used it seriously, so expect rough edges in places I never walked through

Free, source on GitHub.

Site : https://infinition.github.io/scriptorium/
Github : https://github.com/infinition/scriptorium

Hello
I published a paper.
Most defenses against fine-tuning poisoning try to detect malicious data or reduce its impact.

I explored a different question:
What if the model simply could not learn certain malicious updates?

The idea is to constrain fine-tuning to a subspace learned from trusted LoRA adapters. Useful adaptation remains possible, but some malicious directions become geometrically unreachable.
A concrete example: a company fine-tunes a model on large datasets coming from users, external sources, or generated data. A small amount of poisoned data could introduce a hidden behavior triggered by a specific phrase or pattern.

Another example is a local or on-device assistant that keeps adapting to its user. Instead of allowing it to learn any possible behavior from new data, its adaptation could be restricted to variations of behaviors already represented by a trusted pool of adapters.
The goal here is not to detect every possible poison or backdoor, but to restrict the space of updates the model is allowed to learn.

I tested the approach on 196 public LoRA adapters, including adaptive attacks specifically designed to bypass the defense.

The results are strong: attack success drops sharply while useful adaptation is largely preserved on tasks covered by the adapter pool.

The paper, code, and experiments are public.

Paper:
https://arxiv.org/abs/2607.05300

Code:
https://github.com/infinition/z-manifold

I would be very interested to see people try to break it.

Built a batch wrapper around Pixal3D + ComfyUI, drop images in a folder and GLBs come out

too much time babysitting ComfyUI jobs manually so I created a watcher that handles it.

Drop images in a folder, it strips the background with rembg, queues the job via the ComfyUI API, and moves the finished GLB to your output folder when done. There's a Gradio panel in the browser to tweak everything live without restarting: steps, token budget, texture res, decimation target. Works with local folders or a network share.

Running it on a 4070 Ti 12GB, roughly 5-6 min per asset at 1024_cascade / 20 steps / 4096 texture.

https://github.com/infinition/Pixal3D-pipeline

Repo has the ComfyUI workflow, a download script for the HF weights, and prebuilt CUDA wheels for the custom ops (flash_attn, cumesh, drtk...) since building those on Windows is a nightmare.

the worst part was getting Python 3.13 + PyTorch 2.11 + CUDA 13 + flash_attn all working togethr. Happy to help if you're setting up the same stack.

Hey everyone,

I’ve been building paradigm-memory, a local-first memory layer for AI coding agents.

The motivation is pretty simple: I got tired of agents forgetting project context, or relying on giant MEMORY.md files that slowly become a messy context dump.

paradigm-memory gives agents a persistent, searchable cognitive map instead.

GitHub:
https://github.com/infinition/paradigm-memory

Website:
https://infinition.github.io/paradigm-memory/

It is:

• local-first: one SQLite file on your machine
• MCP-native: works with Claude Code, Codex, Cursor, Cline, Continue, Gemini CLI, OpenCode, etc.
• auditable: every write / delete / import / move has a mutation log
• multi-agent: several agents can share the same memory store
• multi-workspace: one MCP process can serve multiple projects
• desktop inspectable: Tauri app with map, graph, search, review queue, audit log, snapshots and consolidation tools
• zero cloud / zero telemetry

The core idea is that memory should not just be a flat vector store.

Instead, facts live inside a cognitive map: nodes, items, keywords, importance, freshness, confidence, activation. When an agent calls memory_search, it gets a token-budgeted context pack with the relevant subtree and evidence, not 50 random chunks from a vector database.

Typical workflow:

1. At the start of a task, the agent calls memory_search.
2. It gets relevant durable project context.
3. When it learns a decision, convention, bug, preference, or architecture detail, it writes/proposes it back to memory.
4. You can review, edit, move, audit, export, import or consolidate everything from the desktop app.

Install is one line:

Windows:

irm https://raw.githubusercontent.com/infinition/paradigm-memory/main/scripts/installer/install.ps1 | iex

Linux / macOS:

curl -fsSL https://raw.githubusercontent.com/infinition/paradigm-memory/main/scripts/installer/install.sh | bash

Then:

paradigm

this is still early, but already useful in my own workflow. I’d especially love feedback from people using MCP-based coding agents: install flow, client compatibility, memory structure, and whether this kind of auditable local memory solves a real pain for you.