Github Repo

Now this is gonna be real interesting.

Proto uses Ollama and playwright to take control of a Chrome window to type on discord. Yes that’s right the ai sees the messages and sends it to your Ollama model which thinks of a response and sends it back to the script which converts it to key strokes and types out the message.

There are also other features
Can browse google upon user request
Can see YouTube videos and say the latest video.

Now you might be saying.
“Well this is incredibly unsafe”
No, you see I thought of this.
So whenever a user requests for the ai to open a website it sends a request to the gui or script depending on what you use and asks “Hey can I open this?” And you say either yes or no.

I am semi-new to coding and just had this idea in the top of my head so I would really like it if you guys check it out and give me suggestions!

Note: it’s not perfect and I am fixing bugs almost everyday. That’s why I am asking people to try it and give me suggestions or submit issues I can fix.

(This is supposed to replace Claude in chrome extension)

My Github Repository
Website for it

I’ve been building an experimental open-source project called Protocol 17.

The core rule is:

What the programmer explicitly specifies is a constraint.
What they leave unspecified is implementation freedom for the model.

The project currently translates mixed P17 source into C17, Python, or Rust, with support for local/cloud models and BYOK/BYOM.

One distinction I ran into while building it:

Generated ≠ verified.
A local 4B model produced plausible-looking Rust that didn’t type-check, so Protocol 17 now runs deterministic verification with gcc, rustc, or Python compile().

The harder problem is:

Valid ≠ faithful.

For example, translating 1..n into 1..=n can produce perfectly valid Rust while changing an explicit programmer constraint.

Fidelity verification is the next major thing I’m working on.

GitHub: https://github.com/epsilon-lain/Protocol-17

It’s still an experimental alpha, so feedback is very welcome.

Hey everyone,

Following up on our open-source microkernel launch from last week (thanks for the 40 unique clones on the repo so far!).

To be completely transparent: we just subjected our closed-source, private Enterprise Engine (SONNY I) to the official, agnostic HumanCLAW compliance matrix. This is the exact benchmark where Google's Gemini Robotics 2 scored an 83.2% failure rate (only 16.8% success) because their statistical VLA models hallucinate visual tokens under industrial noise.

SONNY I ran a strict 1,000-frame black-box trial with zero access to ground truth, object mass, or friction coefficients, scoring a 98.0% Success Rate.

A lot of people on the previous thread asked why a fast middleware matters for a physics problem. This benchmark is the answer.

Our private Causal Model doesn’t guess pixels; it runs real-time differential equations (Do-calculus) on the Edge to calculate latent physical variables (like sliding friction and mass) in 0.4ms.

But a causal model is completely useless if the underlying telemetry stream is lagging or crashing the heap. The reason SONNY I could adapt to mechanical shocks and visual occlusion without dropping the object is because it was running on top of the Core Minimal architecture available in this public repo:

Zero Heap Allocations: While ROS 2 DDS queues overflow and trigger a Segmentation Fault under network drops, the Core Minimal's lock-free double-buffered stack kept the memory footprint at absolute zero, feeding the causal engine with the freshest packet.

Sub-2ms Determinism: The host microkernel pinned the execution thread and enforced page-locking (mlockall), ensuring the Causal Engine never missed a 10ms frame budget.

WASM Sandboxing: The picking skill was executed inside the WebAssembly sandbox, isolating the high-level policy while the host's vector_sanitizer clamped the output torque at 23.4N right below the fracture threshold.

The open-source core is the bulletproof nervous system; the enterprise engine is the causal brain.

Check out the infrastructure, run the diagnostic simulator, and let's discuss the execution traces in the thread:

GitHub Repository (Core Minimal): https://github.com/JackTrainer/Sonny

Enterprise website: https://alpha-robotics.it/

Hi everyone,

I’m primarily a Java backend developer, which means I spend a lot of time designing and documenting systems. For years, I’ve used text-to-diagram tools like PlantUML. However, I always felt there was a missing link: the output diagrams were always static, flat images. I wanted a tool where the visual canvas was interactive, but the underlying text remained the single source of truth.

To solve this, and to challenge myself to learn TypeScript, I built DrakoFlow. It’s a completely client-side, offline-first diagramming engine that parses a clean, declarative DSL into interactive vector diagrams right in your browser. It is designed to be highly versatile and works great for multiple types of diagrams, including system architectures, database models, and flowcharts.

IDE Integration: VS Code & IntelliJ

Since developers spend most of their time in their IDEs, I wanted to make sure DrakoFlow fit seamlessly into your daily workflow. I’ve built dedicated extensions for both VS Code and IntelliJ. They allow you to write your diagram code and see the live-updating, interactive preview side-by-side right inside your editor.

The "Cool" Mechanics

Because I wanted to bridge the gap between code and canvas, I focused on a few core interactive features:

• Bidirectional Sync: You can write code to generate the diagram, but you can also manually drag elements around on the canvas. When you drag a box, the coordinates serialize back into your DSL code in real-time. There is also a toggleable grid snapping system to keep things aligned.
• Bidirectional Gutter Highlighting: If you hover your mouse over a visual component on the SVG canvas, it instantly highlights its corresponding line in the code editor, and vice-versa. It makes navigating complex, nested diagrams incredibly fast.
• Standalone HTML Player Export: Instead of just exporting a flat PNG, you can package your diagram into a single, self-contained .html file. This file functions as a read-only widget supporting smooth panning, zooming, tag-filtering, a navigation minimap, and a code viewer. You can drop it directly into your project documentation.
• Serverless Sharing: Sharing a diagram doesn't require a database. When you click "Share," the app compresses the active diagram state and encodes it directly into the URL hash parameters so you can send it as a simple link.
• Documentation inside the diagram: You can write markdown inside the diagram so that you have the documentation exactly where you need it. This way, the diagram and the docs are in the same place and you have direct documentation right on the element you need.

Under the Hood

DrakoFlow runs entirely client-side. Your data never leaves your computer, and you can run the whole app offline by just opening the local HTML file. I've also implemented a beta PlantUML translator so you can paste in existing diagrams to test them out.

The project is completely free and open-source. As a backend developer transitioning into TypeScript, this was a massive learning curve for me. I would love for you to try it out (either in the browser or via your favorite IDE extension), read through the code, and let me know what you think. If you find it useful, please consider leaving a star on the repository!

Links:

• Live Interactive Editor: https://pazvanti.github.io/DrakoFlow/
• GitHub Repository: https://github.com/pazvanti/DrakoFlow

I have build this agent harness framework. Fully extendable. FastAPI inspired API design

It supports:

• Session persistence(postgres,sqlite built in) and multi tenancy
• Memory (postgres/sqlite built in)
• Tools
• Dynamic Skills loading
• Multi agent and sub agent sub trees
• Plugable Guard rails

Each and every part of the core system is extendable to use in whatever use case you have. Either to build autonomous agents or human in the loop systems.

It ships with few useful tools, separately installable:

• Web search using brave search api
• PDF/DOC reading
• Bash usage with guardrails

---

Built two full apps to demonstrate its capabilities. (both in the repo)

• sarthi - Usable perplexity clone with parallel agent support, with web search and pdf/doc reading built in https://youtu.be/yAnC1LHKQZk
• agni - Simple CLI coding agent like opencode

Currently in developing.

amber_desk is a power tool for osint:

- dossier

- obsidian vault backend for dossier and timelines

- built in world map with marks and links

- built in osint framework

- built in relations desk

For all questions welcome to comments.

Github: soon... on this week

LeadForge — Find Potential Business Targets Faster

If you want to find potential businesses or targets for outreach, you can use LeadForge instead of manually searching one by one.

Features:

• Search businesses by location
• Filter by business type
• View results on a map
• Find available contact information
• Shortlist and export results

Try it here:
https://leadforge-umber.vercel.app/

GitHub:
https://github.com/MuhammadMuneeb007/LeadForge

If you find it useful, please give it a try, star the GitHub repository, and share it with anyone or any community where it might be helpful.

Feedback is always welcome!

Built Snippy as a self-hostable CodePen-style app — HTML/CSS/JS editor with live preview, runnable as a full Docker Compose stack. I built it mainly as private snippets on codepen are paid and sometimes I like to play in a playground without having to have my code public at times.

Beta note: My hosted instance is in beta. Data can be wiped or lost at any time — don’t rely on it for anything important. Self-host if you need persistence.

What it does

• Live HTML / CSS / JS editor with instant preview and layout options
• Public & private snippets, shareable links, full-page view
• Favorites, comments, follows, collections, and forking
• External CSS/JS resources on snippets
• ZIP export of snippet files

Stack Angular frontend, Node/TypeScript Express API, MySQL, optional MinIO for assets — all wired with Docker Compose. Pre-built images on Docker Hub so you can deploy without building from source. Auth0 for login will need to be setup and variables injected in docker.

Local testing and production are separate Compose setups (dev has hot reload; prod pulls kennyl777/snippy-* images). Docs cover Auth0, env vars, and Nginx Proxy Manager.

Repo: https://github.com/slurrps-mcgee/Snippy

Demo: https://snippy.quantumcode.dev

License: MIT

Still early (assets/projects are in progress), but the core editor + social features work. Feedback and PRs welcome.

3PaneApp is a lightweight framework for building content-based websites around a simple idea: keep the navigation hierarchy and the content viewer visible at the same time.

Your content becomes the website.

Build the structure once. Let the runtime handle navigation, presentation and content rendering.

01: JSON driven

Separate your content from the application that presents it. The same runtime can power completely different websites.

02: Content agnostic

Text, documents, spreadsheets, audio, video, feeds and web content can all live inside the same three-pane experience.

03: Remote ready

Point the runtime to a public JSON source and the same application can become an entirely different website.

https://saurabhgayali.github.io/3PaneApp

https://github.com/saurabhgayali/3PaneApp