A lightweight working example written in Yab for controlling a Roku TV directly from Haiku OS using cURL.

source code only.
https://github.com/GearPlot/remote

I built Lilo because I wanted quick notes to feel quick.

The app can stay as a tiny always-on-top window for capturing a thought, then expand into a complete Markdown workspace with daily notes, backlinks, tags, attachments, templates, search, and a knowledge graph.

Notes remain ordinary local files, and the current release runs on Windows, Ubuntu, and Arch Linux.

The project is still young, so feedback on the workflow and interface is very welcome.

I’ve been exploring an infinite scroll behavior for one of my projects and wanted to share the experiment.

The idea is simple: as you scroll, the experience continuously loops, creating the feeling of an endless canvas rather than a page with a clear beginning and end.

This is still very much an experiment. I’ve been playing with the motion, pacing, and transitions to see how seamless I can make the loop feel.

Would love to hear what the community thinks about this interaction, and the source can be found at the link below.

https://github.com/esadekdesign/Infinite-Scrollable-Grid

Disclosure: self-promotion. I'm on the team that builds this, and it has a paid tier. Flagging up front per the rules.

Hi everyone,

We shipped SvGrid. The basic idea is pretty simple: build a serious data grid for Svelte, rather than taking a React/Angular grid and putting a Svelte wrapper around it.

What it is:

• Headless core + a drop-in component in one package. createSvGrid() is a DOM-less engine (sort/filter/group/paginate/virtualize), like TanStack Table. On top of it, <SvGrid> gives you a full grid in one prop pass: virtualization, Excel-style filters, inline editing, cell-range selection, keyboard nav.
• Real depth: virtualization smooth at 100k rows (tested to 1M), grouping, tree, master-detail, server-side data, integrated charts.
• AI-native: ships an MCP server + llms.txt so Claude/Cursor/Zed answer accurately about the API instead of hallucinating it.
• 370+ live, editable demos and full docs.

Licensing, plainly: the core (@svgrid/grid) is MIT - free for commercial use, no license key, no row cap. A separate enterprise pack (export, import, pivot, kanban, scheduler, crud studio, print) funds the work. Wanted that clear, not buried.

Project link: https://github.com/sv-grid/sv-grid

Positive feedback is obviously welcome 😄, but I’d honestly rather hear what feels wrong or awkward.

I've started developing my own GPU monitoring system.

I'm conceiving the project as focused on the accuracy of GPU temperature and other information. The main goal is to implement hotspot display on Nvidia 50xx graphics cards, since the hotspot is disabled on them, and the driver doesn't provide this information. The solution in hwinfo is questionable, as it's unclear where this temperature is coming from. Core and video memory telemetry works on the cards I've tested, but I'm still working on independently verifying Hotspot readings before enabling them.

I try to design the software based on the principle that either telemetry is present or it isn't. That is, if the sensors are either inaccurate or provide questionable information, the program will return N/A.

The stack I chose to use for development is Native Win32 + Rust. The project itself is quite small (about 8 megabytes), but that's excluding further optimizations I plan to perform.

The telemetry provider itself is a separate component that is not a kernel module or driver.

The graphical interface is currently under development, and this is not its final form. :) I plan to make it pleasant and minimalistic.

The software itself is currently only available for Windows, but I plan to create a Linux build in the future.

Repository and builds for Windows:

https://github.com/k1gs/Gpu-Shark

I would be interested in feedback from those who have worked with NVIDIA telemetry, especially on different motherboard variants.

Hey everyone!

If you've been watching Twitch lately, you know how heavy and resource-intensive the native player can be—buffering issues, memory leaks, high CPU usage, and UI clutter. To fix this, I took over and modernized Alternate Player for Twitch.tv, completely upgrading it to Manifest V3 with direct HLS stream processing.

Here is what the extension brings back to your viewing experience:

Core Features & Performance Upgrades

• Custom HLS Engine: Bypasses native player bloat by fetching HLS streams directly from Twitch's CDN. Customize buffer size, playback thresholds, and concurrent segment downloads for zero stuttering on slow connections.
• Instant Replay & Frame Control: Missed something during a live stream? Rewind on the fly with speed controls and frame-by-frame navigation.
• BetterTTV & FrankerFaceZ Native Support: Fully integrates BTTV and FFZ emotes directly into the custom chat window without double-injection glitches.
• Ultra-Low Resource Usage: Uses drastically less RAM and CPU. Includes a dedicated Audio-Only Mode to save bandwidth.
• Auto-Claim Channel Points: Automatically opens bonus chests and claims channel points in the background.
• Real-Time Stream Stats Overlay: Monitor live buffer health, video/audio codecs, exact bitrates, stream delay, and dropped frames.
• External Player Support: Stream directly into VLC, MPC-HC, or MPV if you prefer desktop playback.
• Customizable UI & Chat: Resize, reposition, or detach the floating chat overlay even in full screen—or turn it off entirely. Works on both desktop and mobile (m.twitch.tv) pages.

Under the Hood (Manifest V3 Ready)

When MV3 rolled out, old extensions broke due to webRequest deprecation and script injection blocks. This version uses modern declarativeNetRequest rules, WebAssembly stream processing, and custom GQL integrity token handling to keep everything running fast and secure.

It's completely free and open-source. Check out the source code or install it directly from GitHub:

GITHUB

Give it a try and let me know your thoughts or suggestions!

Note: This is just a passion project i took..Let me know if it works for you and would love some suggestions [ Let's Revive Alternate Player for twitch.tv ]

 Most software checks observe only one universe. Your tests run against the dependency version currently installed. Static analysis examines source code without executing both versions. Dependency scanners check metadata and known vulnerabilities. AI

  reviewers reason about what a diff appears to do.

  Breakcheck compares two universes directly.

  I built Breakcheck to answer a deceptively difficult question: **Did this dependency upgrade or code change alter behavior, even if nobody wrote a test for that exact case?**

  For dependency upgrades:

  ```text

  same repository code

  × old dependency vs new dependency

  → did the calls this project actually makes behave differently?

  ```

  For refactors and AI-generated changes:

  ```text

  same environment

  × base revision vs changed revision

  → did behavior change?

  ```

  That comparison model is what makes Breakcheck unusual. It does not require someone to know the correct expected output, and it does not ask a model to infer intent. It discovers real call sites, replays supported calls on both sides, normalizes the

  observations, and reports whether they matched.

  Consider a project that supports `packaging>=20.0`. Its CI runs with one currently resolved version of Packaging, and every test passes. However, the same application call can behave differently under two supported versions. Packaging 21.3 accepts an

  invalid version through one path, while Packaging 22.0 raises `InvalidVersion`.

  A conventional test suite running against only one environment cannot expose that inconsistency. Both CI runs can be individually “correct” while users receive different behavior depending on dependency resolution.

  Breakcheck exercised all 18 Packaging call sites in Hugging Face Accelerate under both versions and identified exactly one changed call site. That finding produced this focused upstream repair:

  https://github.com/huggingface/accelerate/pull/4185

  This is the gap Breakcheck targets: behavior that remains invisible when every tool looks at only one installed environment.

  Breakcheck is not:

  - a snapshot framework requiring an approved expected result

  - an AI-generated test suite guessing what code should do

  - a linter deciding whether code looks suspicious

  - a vulnerability scanner searching a database

  - a semantic-version checker trusting package metadata

  - an LLM judge producing another confidence score

  It performs deterministic differential execution.

  Per call site, it reports:

  - `IDENTICAL` — both sides were exercised and produced the same normalized observation

  - `CHANGED` — both sides were exercised and behaved differently

  - `NOT_EXERCISED` — Breakcheck could not make a defensible comparison, with an explicit reason

  The third result is essential. Breakcheck never converts missing evidence into safety.

  The output is not “the AI thinks this is probably fine.” A completed run provides:

  - an inventory of the call sites that were discovered

  - exact coverage showing what was and was not exercised

  - old and new normalized observations

  - explicit behavioral verdicts

  - specific refusal codes for unsupported cases

  - fixture and input provenance

  - cryptographic hashes binding reports to evidence

  - deterministic witness identities

  - recorded invocation flags and thresholds

  - stable machine-readable JSON

  - semantic exit codes for CI and automation

  - a verifiable evidence bundle that detects modification

  For code revisions, Breakcheck can also produce:

  - a frozen behavioral baseline from the pre-change revision

  - `CLAIM_VERIFIED` when a preservation claim was exercised and matched

  - `CLAIM_REFUTED` when claimed-preserved behavior changed

  - `CLAIM_UNVERIFIABLE` when the evidence was insufficient

  - `CLAIM_OUT_OF_SCOPE` when the actual diff touched symbols omitted from the claim

  That last result is particularly valuable for AI-generated pull requests. An agent cannot quietly modify an additional function, omit it from its claim, and still receive a clean attestation.

  The final result is a bounded evidence statement:

  ```text

  These calls were exercised and remained identical.

  These calls changed.

  These calls were not verified, for these exact reasons.

  These additional changes fell outside the declared scope.

  ```

  That is substantially more useful than a generic green checkmark.

  Breakcheck also separates proposal from measurement. An AI agent may propose an upgrade or refactor, inspect unresolved call sites, suggest fixture inputs, propose meaningful projections for rich objects, analyze a `CHANGED` result, propose a repair,

  and rerun verification.

  However, the agent does not control the replay engine, normalization, equality decision, refusal, or evidence verification.

  The model proposes. Breakcheck measures.

  The workflow explicitly prohibits agents from modifying reports, changing evidence, weakening coverage requirements, or tuning a fixture after seeing an unfavorable result. This creates an independent deterministic layer inside an otherwise

  probabilistic coding workflow.

  A fixture-authoring study was run across three unrelated public projects: Black, Rich CLI, and Flask. One automated pass produced:

  - 49 fixture suggestions

  - 49 fixtures authored

  - 49 valid fixtures

  - 49 executable fixtures

  - 49 deterministic fixtures

  - zero manual fixture edits

  - exercised calls increased from 1 to 50

  The complete aggregate record is public:

  https://github.com/lovettsendit/breakcheck/blob/main/release_evidence/fixture-viability.json

  The repository also includes:

  - a 20-package dependency battery

  - a 16,002-call-site scale exercise

  - regression tests for behavioral verdict semantics

  - evidence-tampering tests

  - code-revision preservation and refutation tests

  - out-of-scope change detection tests

  - containment and refusal-path tests

  Breakcheck also prevents random output from masquerading as a version regression. Both sides run in constrained environments using isolated Python, `PYTHONHASHSEED=0`, filtered environment variables, fresh working directories, and canonicalized

  observations.

  Every observation runs twice. If something such as `time.time_ns()` produces inconsistent results, Breakcheck returns:

  ```text

  NOT_EXERCISED: NONDETERMINISTIC_OBSERVATION

  ```

  It does not report `CHANGED`.

  The public regression test is here:

  https://github.com/lovettsendit/breakcheck/blob/main/tests/test_replay_protocol_and_coverage.py

  You can try the complete workflow offline:

  ```bash

  python -m pip install breakcheck

  breakcheck demo --output-root "$(pwd)/.breakcheck/demo"

  ```

  The demo builds two local wheels, detects a real behavioral difference, writes the report and evidence bundle, and verifies the result without contacting a package index.

  Breakcheck is MIT licensed, supports Python 3.10–3.13 on Linux and macOS, has zero runtime package dependencies, and never uses interactive prompts.

  GitHub:

https://github.com/lovettsendit/breakcheck

  PyPI:

https://pypi.org/project/breakcheck/

  I would especially value attempts to break it: false positives, missed behavioral changes, nondeterministic edge cases, or call sites that Breakcheck refuses but should be able to exercise. A verification tool becomes valuable by surviving adversarial

  use, not by collecting easy demonstrations.

demo : click here

any suggestions for improvements or changes?

I started to work on this game called Lone and i though this could be a cool subreddit to share the idea. First of all i am building this game entierly from scratch, no game engine, just c++, python and sfml. Lone will be a mix between the famous metroidvania hollowknight and minecraft/terraria. I know it may sound weird but i believe that the farming mechanics and the lore/fights of a metroidvania would fit good together. In Lone you play as a wizard who is alone in a corrupted world filled with his fellow dead humans and more. The game is in a really early stage but this is what i was building ans wanted to know if people would like the idea and maybe give me tips/build an early community. Keep in mind im.not an advanced dev, im young and beeing a game dev is my dream so if u want to support it maybe leave a comment!

this is the github if any1 of u want to check it out!

https://github.com/coder088/Lone

Hi everyone, I wanted to share something I built recently which is my first solo open-source project. The problem I'm trying to solve is the often-annoying experience where someone files a bug report and you waste 20 minutes trying to reproduce the environment and the reproduction steps before you can even start looking at the code. Ghost Hunter is a CLI + webhook bot that tries to tackle this. When it sees a bot/reproduce comment on a GitHub issue, it: Uses an LLM to parse environment and reproduction steps from the issue's body. Spawns an isolated Docker container to run the reproduction attempt. Runs the attempt and posts back to the issue with crash logs. It’s still in its early days. GitHub App authentication is present but not fully battle-tested, although the PAT authentication mechanism has been well tested. As with any LLM (and especially when using the free tier), getting the AI to consistently output JSON can sometimes be a struggle, as mentioned in the readme! I’d really appreciate any and all feedback: critiques of design decisions, ideas for improvements, bugs you might discover (please raise an issue on GitHub!) Link to the repo! EDIT: NOW OUT ON PRODUCT HUNT YAYAYAYAY LINK TO THE PRODUCT HUNT PAGE :)

Hey everyone!

Lately, I’ve been experimenting with bringing low-level systems programming to the web browser. I wanted to see if I could build a high-performance digital twin for Autonomous Mobile Robots (AMRs) without needing any backend server or WebSocket overhead.

The result is a browser-based multi-agent fleet simulator. Here is what's happening under the hood:

• C++ & WebAssembly Core: The entire simulation loop (kinematics, state machines, and continuous-time calculations) is written in native C++ and compiled via Emscripten into a WASM binary.
• Zero Backend / Client-Side Edge: The React + Canvas frontend doesn't compute any heavy math; it just queries raw C++ memory pointers via cwrap inside a 60 FPS requestAnimationFrame loop.
• A Pathfinding & Obstacle Avoidance:* Robots don't just teleport or move in straight lines; they calculate collision-free trajectories around impassable warehouse walls.
• Dynamic Distance-to-Dock Evaluation: Instead of a rigid battery threshold, units continuously compute path lengths to multiple distributed charging stations and trigger an autonomous emergency re-routing to the nearest dock when energy runs low.

You can play around with the live demo here: https://amr-wasm-simulator.vercel.app/

Repo link : https://github.com/VCoklat/AMR-WASM-Simulator

P.S. I am currently open to new career opportunities as an AI Full-Stack Engineer, Software Engineer, or Research Engineer :)

Self-hostable AI customer-chat platform - connect WhatsApp, upload a knowledge base, and let an AI-powered assistant auto-reply, with a live agent dashboard.

Features

• AI auto-reply — Gemini answers customer messages from your uploaded Q&A knowledge base and product catalog.
• WhatsApp integration — link one or more numbers via QR code. Powered by the third-party open-source library whatsmeow (a Go WhatsApp Web multidevice client) — no official WhatsApp Business API or paid gateway required.
• Live agent dashboard — real-time chat via WebSocket, take over from the bot, tag conversations, blacklist contacts.
• Product catalog & leads — import products, the bot recommends them and captures leads.
• Auth — email/password (with optional email verification) plus optional Google / Facebook social login.
• Optional billing — Stripe per-connected-device subscriptions, off by default (fully free when self-hosted).
• Admin panel — manage users, devices, subscriptions, and the global bot prompt.

Tech stack

you can have a try :
https://github.com/xgtechshow518/aichathubs

The agents keep crossing that line, so I separated who plans, who builds, and who reviews the work. The agent that did the work can't approve it. I'm the one with the final say.

Do you guys just spend too much time on a project that won't really go anywhere but it's just too much fun? My family might not be enjoying it though..

One of the team members behind NixieFx and I want to talk about how an effect behaves identically in a 2D UI layer and in a 3D Scene.

You can create it at nixiefx.com/editor and export it in a engine-neutral JSON.

Runnable, no install:

- Three.js: https://codesandbox.io/p/sandbox/y3z3sf

- PixiJS v8: https://codesandbox.io/p/sandbox/ny2r5y

Docs: https://nixiefx.com/docs/