https://github.com/muellerberndt/cadence

https://cadence.floatingpragma.ai/

github.com/ddkbs/sketchy

LLMs are great at explaining but bad at drawing. When they write SVG directly, boxes overlap, arrows point nowhere and labels get cut off.

So I built Sketchy, a free open source tool that splits the job in two. The AI only describes what should be in the drawing in a compact text format. A layout engine (elkjs) calculates all positions and rough.js renders it in a hand-drawn style. The AI decides what, the engine decides where.

What it can draw:
- freely, not just boxes and arrows: molecules, objects, scenes, whatever explains it best
- flowcharts, architecture diagrams, comparisons, metaphors
- interactive step by step mode and hover details
- Arduino/ESP32 wiring diagrams

The AI part:
- photo labeling runs locally with Florence-2, you pick small (~280MB), medium (~830MB) or large (~3.1GB) depending on your hardware
- the compact text format instead of JSON saves tokens and breaks less
- in my benchmark a drawing answer averaged ~29% fewer output tokens than the same answer as plain text

It works in the normal Claude chat as a skill and as an MCP extension. MIT licensed, written in TypeScript. Docs are at sketchy.davidkubus.dev/docs

Would love to hear what you think, especially if you've tried similar "LLM describes, engine renders" setups!

Marimba is like Jev, but for audio.

I built it to be fast and lightweight, and to return typed decisions about speech: yes/no, a choice, or a score.

It runs on a frozen Qwen3-ASR-0.6B. Word and language questions use zero-shot scores from the ASR decoder's hypotheses, followed by calibration. Small readouts on the frozen encoder handle voice activity, turn endings, speaker changes and speaker count.

Open weights (Apache-2.0), pip install marimba-audio. Paper on arXiv this week.

Code · Model · Benchmark

I built J.A.S.O.N. — LLM App Security, an open-source defensive security skill for apps built with LLMs and coding agents. I’m looking for developers, indie hackers, and security practitioners to test it and share honest feedback.

The name comes from my own name, Jason, with a playful Friday-the-13th reference:

Just Audit, Secure, Observe, Notify.

The chainsaw is a joke. Exposed credentials and missing authorization checks are real problems.

AI coding tools help us ship quickly. Security still requires checking where secrets live, who can access each endpoint, which records users can read, and what an agent is allowed to do.

J.A.S.O.N. gives your coding agent structured instructions and supporting scripts to investigate those questions. Tested with Claude Code and OpenAI Codex CLI.

Review before deployment

Check for exposed API keys, routes without authentication, weak database rules, missing ownership checks, unsafe payment logic, and missing rate limits. Get prioritized findings, suggested fixes, and a deployment verdict. The quick review is read-only.

Run structured audits

Review an entire project, a pull request, or a specific subsystem. Full audits produce an architecture overview, a coverage ledger, structured findings, and a readable report separating confirmed issues from items needing validation.

Catch common AI-generated code pitfalls

Look for authorization enforced only in the interface, access to other users’ records, permissive Supabase/Firebase rules, injection vulnerabilities, suspicious dependencies, and unsafe LLM tool permissions.

Review defenses against agent manipulation

Identify suspicious instructions hidden in repository content and review agent permissions and sandbox boundaries. Content being audited is treated as data, not instructions to obey.

Set up passive detection

Get guidance for honeytokens: fake credentials or other bait connected to an alerting service. Attempts to use them can trigger notifications. No retaliation or destructive traps.

Add release controls

Get guidance for secret scanning, dependency hygiene, and PR security gates. Integrate the included zero-dependency ship-gate.cjs script to block deployment when its checks detect security blockers. Coverage depends on configuration and available inputs.

Try it in Claude Code:

/plugin marketplace add jasonmello/llm-app-security
/plugin install llm-app-security@llm-app-security

Then ask:

Review this project as if you wanted to break into it. Look for exposed API keys, routes without login, and databases without access rules. List what you found and how to fix it, without changing anything yet.

Or:

Run a full security audit with J.A.S.O.N.

I’d love feedback on installation, useful findings, false positives, missed vulnerabilities, report clarity, and deploy-gate behavior in your stack.

Share your agent, stack, and reproducible examples. Keep credentials and unresolved vulnerabilities out of public reports.

Use it on projects you own or are authorized to review. A clean report means no findings in the areas reviewed, rather than a guarantee of security.

Try it, challenge its findings, and help make it better.

Get J.A.S.O.N. — source, installation, and documentation

Ship on Friday the 13th. Fearlessly.

I'm the maker of CaptureFlow, an open source screen recorder. You record your screen and camera, and you get a link you can share with anyone.

What it does:

• Records your screen, with your camera and microphone if you want them

• Gives you a share link for every recording, so there's no file to upload or send

• Runs as a Chrome extension, so it works on Mac, Windows and Linux

• Adds a transcript and captions to your recordings

• Can be self-hosted with Docker or on your own Cloudflare account, so your recordings stay on your side

• Has an MCP server, if you want an AI agent to record a demo for you

It's free to use, and the code is public:

Code: https://github.com/sardorml/captureflow

Site: https://captureflow.dev

A Mac app is on the way. If you try it, I'd like to hear what works and what doesn't.

Hello community,

I have built an optimizer that beat Adam on your CPU for all your ML experiments.

Please take time to experiment with it from my github source and read the release notes from Release v2.3.0 - CIFAR-10 validated, Adam m fix · dskc/peanut before experimenting

Regards,

I built an experimental skill packaging standard for LLMs — looking for independent testers

I'm working on SKILLPACK, an experimental approach to packaging deterministic software functions so different LLMs can discover, combine, and execute them without rewriting the underlying code.

The goal isn't to build another foundation model. It's to test whether existing models can act as coordinators of reusable software components.

Some initial CLI tests have passed, but cross-model portability and real-world reliability are not yet independently verified.

I'm looking for developers willing to inspect the packages, run the tests, and identify where the architecture breaks.

I'd especially appreciate critical technical feedback.

A Siamese Neural Network is a type of neural network designed to measure the similarity between two inputs. For example, suppose we provide two handwritten digits as inputs. The Siamese Network determines whether these two digits belong to the same class or are dissimilar.

It consists of two identical neural network branches that share the same weights and biases. Each branch takes one input and produces an output vector (embedding). These two output vectors can have any dimensionality, depending on the architecture of the network.

We then calculate the Euclidean distance between these two output vectors. If the distance is close to zero, the two inputs are considered similar. If the distance is sufficiently large (above a predefined threshold), they are considered dissimilar.

Note: A Siamese Network is fundamentally different from a traditional classification network. Its primary purpose is not to classify an input into a particular class but to learn a meaningful representation (embedding) that allows us to measure similarity between inputs.

Contrastive Loss

A Siamese Network commonly uses a loss function called Contrastive Loss, defined as:

L = Y × D² + (1 − Y) × max(0, m − D)²

Where:

D is the Euclidean distance between the two output vectors.

Y is the given label (either 0 or 1).

Y = 1 indicates that the two inputs are similar.

Y = 0 indicates that the two inputs are dissimilar.

m is the margin, which defines the minimum desired distance between dissimilar pairs.

L is the contrastive loss.

The objective is to minimize the distance between similar pairs and push dissimilar pairs at least m units apart.

We pass two inputs through the network, obtain two output embeddings, calculate their Euclidean distance, and then calculate the contrastive loss. Finally, we use backpropagation to update the network parameters and minimize the loss.

Notice that we do not use a Softmax activation function in the output layer because we are learning embeddings rather than class probabilities.

Training the Model

To train a Siamese Network effectively, we construct pairs of inputs:

Positive pairs: Two inputs belonging to the same class (Y = 1).

Negative pairs: Two inputs belonging to different classes (Y = 0).

A balanced dataset containing an equal number of positive and negative pairs is a useful starting point for training.

My Implementation: Neural Canvas (Model 5)

I developed an interactive Siamese Network as the fifth model in my Neural Canvas project. I used the MNIST handwritten digits dataset to train the network.

The architecture consists of three hidden layers, each containing 40 neurons, followed by an output layer containing 32 neurons. Therefore, each input is transformed into a 32-dimensional embedding.

I used Mini-Batch Gradient Descent with the Adam optimizer to train the model. The training process was relatively straightforward because JAX provides automatic differentiation (autograd), which handles the gradient calculations.

For training, I constructed two input matrices, Ma and Mb, each having dimensions of (784, 80000).

The rows represent features, while the columns represent individual samples. Why two matrices? Because a Siamese Network requires two inputs to learn the similarity between them.

I also constructed a label vector Y with dimensions of (1, 80000). Each element of Y indicates whether the corresponding pair is similar or dissimilar.

I used my own matrix multiplication convention:

Z = WX + bC

Where:

W represents the weight matrix.

X represents the input matrix.

b represents the bias vector.

C is a broadcasting matrix of ones.

I prefer this notation because it makes the mathematical operations and dimensions easier to understand.

I trained the model in Python using JAX and exported the learned parameters to JavaScript using JSON. For inference, I used Math.js, while p5.js handles the visualization, animation, and interactivity.

Try it yourself:

GitHub Repository: https://github.com/MuhammadEssa2002/neural_canvas

Live Demo: https://muhammadessa2002.github.io/neural_canvas/

This is the fifth model in my Neural Canvas project.

Humble developer seeking out a army. 15 year software developer here. 20 years in total. Started out in high school. I am 42 years old so I am old school millenial. Never went to college, self taught. The open source community taught me coding. And although I am out of job due to AI, I don't give up on what I love to do. Fight fire with fire.

My goal now is to fight the big corporations and make sure they do not control of the narrative of the future of AI.

Introducing Infantry AI.... Completely Opensource, Completely overridable. A AI Framework if you will

Build your own plugins and publish them on Git.

There is more to come but I need a army. Contribute or Star my Opensource Project

Future Goals is to Decoupling the AI Market Place. Make money off your AI Machine based on tokens.

Build Secure Docker Based Workspaces and loan your open weight models completely bypassing the Big Corps. A user to user Open Weight Marketplace if you will. With NDA based signings to secure your projects. This is one of many future goals to decouple and bring back Opensource power to the AI Booming Industry.

If this sounds like something your interested in , contribute by starring the project and contribute by building new plugins. I have a SDK too

Built on Kotlin Multiplatform to build on web/mobile and desktop mac and windows.

Git

https://github.com/SuperiorSoft-LLC/infantry-ai
Site
https://infantryai.superiorsoftllc.tech/

I kept forgetting who minor characters were mid-book, and every search spoiled something. So I built LORE.

What it does:

- Upload your own EPUBs. It extracts characters, places, events and relationships into a graph.

- Ask questions ("How did Watson meet Holmes?"). Every sentence in the answer cites a passage from the book, and the claims are checked against those passages before you see them.

- Set your reading progress per book and it only uses what you've read. Ask "who's the killer?" at chapter 4 and it won't say.

- Deep dive mode writes longer cited analyses: themes, how a character changes across a series, how a world or magic system works.

Tech, for the curious: GraphRAG (Kuzu graph + LanceDB vectors), local embeddings, bring your own key for Gemini, Claude or OpenAI. It also exposes an MCP server, so you can use your library from inside Claude.

Open source: github.com/Jatin-Roopchandani/LORE (star it plzz)

Hosted beta (invite-only): https://lore.jrvn.site Comment if you want an invite.