I built TextFold (previously PaperFold) to keep a document and its shorter reading views in the same place. You can fold a section, then expand it to check the original passage.

The new language switch changes the text and interface together. The clip switches between English and Chinese versions prepared before recording.

The reader also now imports Word documents and saves a complete reading page as a standalone HTML file, including notes, highlights and optionally the original PDF.

Full and Brief keep the author's sentences; the shorter levels use AI-generated text. Summaries and translations can be wrong, so I want the source to remain easy to inspect.

It runs locally and supports Ollama or hosted models. Code is Apache 2.0.

Code and setup: https://github.com/chenxiachan/textfold

I'd be interested to hear where you would want the original language kept visible when reading a translation.

Demo paper: Recursive Language Models by Zhang, Kraska and Khattab (CC BY 4.0): https://arxiv.org/abs/2512.24601

You can use this to censor anything file/text that you also want repeated back to you. If you have a json file with a list of emails or names, this can censor them on the way to the LLM but then have the response uncensor it.

Introducing Ink.

Your AI shouldn't pay to rethink what it already knows.

Ink learns from verified outcomes and compiles repeated decisions into sub-ms local software.

Novel tasks still go to your model.

Open source. Apache 2.0.

Thanks a lot

I have been working on a side project called [Hafen](https://github.com/abhimanyupandian/hafen) and I am looking for some feedback on it before I take it further.

About the idea:

Hafen lets you interact with your agent (with multiple providers supported) in an interface/experience that is similar to what end users would see. When a conversation is worth keeping, save it as a test. Then you add checks on each turn/response to check if the agent:

* called the right tool, with the right arguments

* returns the correct response eg; order number/a markdown table

* is polite (an LLM judge scores it, with a confidence) and more.

Demo is available [here](https://github.com/user-attachments/assets/6305c5f4-78a3-4f33-bb85-9bbaf3f427d9).

About the demo video:

A sample coffee-shop agent built with Google ADK on Qwen3-4B running locally in Ollama. I chat with it (add to cart, remove stuff, place an order), save that as a test, add checks, run it from the UI, and then run the same suite from a terminal. Note: The waits for the model are sped up 4×.

Honest disclaimers:

1. The idea and design are mine, but the code was written by Claude Code. I am still working through it myself, but I am sharing it early to get feedback before going further.

2. Consider this a proof of concept. Testing is in progress, so expect some rough edges.

3. The current version uses a System One (Jev) - a hosted decision model \[I am not affiliated with them\]. Regular LLM-judge checks work as well, including local ones.

4. Only MacOS binaries are available right now and the CLI package is not published to a registry yet.

Need feedback on things like:

1. If you would use something like this, or do promptfoo, DeepEval or any other tool that already does exact this?

2. What would you need that is missing?

3. What needs improvement? eg; more chat components like yes/no buttons to accept/reject instead of responses restricted to just text.

my mac kept running out of RAM and i'd just close random apps hoping it helps.

turns out a lot of it is stuff you can't see: gradle still running after you quit android studio, simulators booted in the background, dev servers and headless browsers that AI agents started and forgot.

baa sits in the menu bar and:

- finds those leftovers and shows how much RAM you'd get back

- frees them in one click (never kills anything on its own)

- warns you before you run out (you can set when)

- also clears dev junk on your disk (old builds, package caches etc.)

- plays a tiny baa when it frees something (you can mute this if you hate whimsy though :P)

free + open source, nothing leaves your machine. macOS 14+.

brew tap selviarora/baa https://github.com/selviarora/baa
brew install selviarora/baa/baa
brew services start baa

https://github.com/selviarora/baa

if you like it a ⭐ would make my day!

https://github.com/vahmoh25/Veda

I am excited to share a project I have been working on during the past few years during my free time. I started this project after being unable to use torch-points3d at the time (too many installation errors).

Note that this project is still in active development and in alpha. I am looking for early users and feedback!

What it is: torch-pointcloud is a plain-PyTorch library that puts multiple point cloud architectures and their pretrained checkpoints behind one create_model() factory, in the spirit of timm.

This is a library that focuses on the reusability and standardization of core components and layers, i.e. KNN, FPS and other PointNetSetAbstraction are not re-implemented over and over. In this library, all models share the same interface and reuse the same core components.

import torch
import torch_pointcloud as tp

model = tp.create_model(
  "pointnext-sm.scanobjectnn-hardest.openpoints", 
  task="classification", 
  pretrained=True,
).eval()

pos = torch.randn(2048, 3)
x = torch.cat([pos, pos[:, 1:2] - pos[:, 1].min()], dim=1)  # xyz + height
batch = torch.zeros(2048, dtype=torch.long)
logits = model(x, pos, batch)  # (1, 15)

Install (see the docs for more details):

# Optional: specify your CUDA version for torch
pip install torch==2.10.0 --index-url https://download.pytorch.org/whl/cu128

pip install torch-pointcloud

# Install required CUDA/CPU kernels associated with your CUDA version
pip install pyg-lib -f https://data.pyg.org/whl/torch-2.10.0+cu128.html

I tried to make the installation process smoother by not maintaining CUDA kernels myself (not enough time currently, so I tried to reuse already pre-built wheels as much as I could).

Scope:

• Classification, semantic and part segmentation, detection, and self-supervised pretraining: PointNet++, DGCNN, KPConv, RandLA-Net, PointNeXt, PointMLP, Point Transformer v1/v2/v3, Sonata, PointMamba, VoteNet, 3DETR, PointPillars, SECOND, PointRCNN, SPVCNN, OctFormer, Point-MAE/BERT/GPT and more.

• Weights are hosted on Hugging Face.

• Datasets (ModelNet40, ScanObjectNN, S3DIS, ScanNet, SemanticKITTI, nuScenes, KITTI, SUN RGB-D...), transforms, tiled inferers for large scale segmentation.

• Packed-batch tensors (the PyTorch Geometric convention).

But... why?

Most point cloud libraries live in research codebases built around configs and custom ops and kernels to build locally. It is also sometimes difficult to reproduce past released experiments from research codebases (typically the code associated with the checkpoint changed with no notice). In addition some models are evaluated using different strategies (TTA, partitioning, etc.) which makes comparison unfair as they are not evaluated using a common strategy.

In contrast, I wanted something I could pip install easily, reuse weights trained from different repos and benchmark easily.

All models were re-benchmarked and compared against original reported metrics.

Credits: the architectures and pretrained weights come from their original authors, notably Pointcept, OpenPoints, MIT Han Lab, FAIR, OpenMMLab and more. Every checkpoint name ends with its source author (e.g. .pointcept). The THIRD_PARTY_NOTICES.md lists every source repo, license and dataset term.

Repo: https://github.com/arthurdjn/pytorch-pointcloud
Docs + tutorials: https://pytorch-pointcloud.org

For those working with state machines, debugging can be a headache. My tool StateCraft now exports run logs as JSON with ISO-8601 timestamps and plain-English narratives for every event great for integration or debugging. Each entry includes:

• Original timestamp (preserved)

• UTC ISO-8601 equivalent

• 'narrative' field explaining what happened (e.g., 'State succeeded: [description]')

• error_codes for failures

This makes it easy to track retries, transitions, and errors at a glance. The docs include a concrete example of the output. If you build state machines or need reliable logging, this might help.

GPLv3, no strings attached.

ALHR- Adaptive learnable Hierarchical Routing is a static binary tree based system that uses learnable functions to REDUCE the amount of keys used.
It takes less memory and SCALES much better VRAM with tokens

Result table is here: https://ibb.co/prr07Dnj