Hello all! Please fill this out to help get rid of the lard that lives in his mother’s basement!

https://www.change.org/opensource

Thanks!

Hi everyone,

I'd like to share N-Zik, an open-source (GPLv3) YouTube Music client for Android. It started as a fork of Kreate and grew into a community project, with performance improvements, UI/UX refinement, bug fixes, and new features built with long-term support in mind.

What it does

• Streams from YouTube Music premium quality unlocks automatically if you connect a YouTube Music Premium account
• Offline: smart auto-caching + real downloads (individual tracks or whole playlists), with a dedicated download quality setting
• Advanced lyrics: fetch, word-by-word sync, edit, and translate in real time
• Song recognition (Shazam-like) and voice search
• Available in 30+ languages via community translation (Crowdin)
• Listening stats + a "Rewind" feature with yearly/monthly recaps
• Listen Together: live listening sessions with friends (N-Zik is an officially supported MetroServer host)
• Desktop companion app (Windows/Linux) to control your library and playback from your PC (very very early stage not mean for use rn)
• Home-screen widgets, Android Auto/TV (still need improvements)/tablet support, Discord Rich Presence, Last.fm scrobbling
• Multi-profile, automatic settings + database backup, parental controls, hidden songs

Where to get it

• GitHub (all builds: 64/32-bit, FOSS, and minified builds for low-end devices): https://github.com/N-Zik-Group/N-Zik/releases
• F-Droid (FOSS build): https://f-droid.org/packages/com.nevar.nzik.foss/
• Official website: https://n-zik.vercel.app
• Discord: https://discord.gg/bneHC7QRje

Honest notes

• N-Zik may not be as stable as the original Kreate yet. If you need a more mature option, Metrolist, VIVI Music, or RiPlay are solid alternatives.
• It's a side project that grew bigger than expected. I use generative AI to assist with the code (structured with the BMAD Method), but everything gets reviewed and tested before it's pushed not shipping blind.
• The project has no affiliation with YouTube or Google LLC.
• i'm currently restructured release, new build aren't out yet still finishing other issue

If you try it, I'd love to hear what works and what doesn't feedback and issues are very welcome on GitHub.

Some series do not move around a fixed value: they alternate between

calm and agitated periods. A return series has this shape, and so does

the vibration of a joint whose load changes over time.

The level of the series is one question;

the volatility of the series is another.

GARCH answers the second.

link git hub : https://github.com/tatopenn-cell/Dense-Armor

pypi: pip install dense-armor

#machine-learning #change-point-detection #opensource #variance #volatility

Disclosure: I work on an LLM gateway (starunion.net), so pricing changes are literally my day job. Posting the analysis, not a pitch.

OpenAI released GPT-6.1 Terra on Oct 26. API pricing:

- Input: $1 / 1M

- Cached input: $0.05 / 1M

- Output: $5 / 1M

That's ~50% under GPT-5.6 Terra and GPT-6.1 Sol.

The interesting part isn't the discount, it's what the discount is pointed at. Terra is positioned around visual reasoning and computer use — screen reading, form filling, clicking through internal tools. Those workloads are token-hungry by nature: the model looks, acts, re-checks, repeats. At half the price per token, a lot of "cool demo" automation becomes economically boring — which is the point where it actually gets deployed.

Reported eval numbers: Agents' Last Exam (medium reasoning) ~15 points over GPT-5.6 Terra at roughly 1/3 the cost. Error-induction test: low tier 53.6% → 16.7% error rate.

Caveats worth flagging:

1. It's gated to ChatGPT Work / Codex — not a general model picker entry.

2. No UAE inference residency support, so check regional compliance if that applies to you.

3. Vendor benchmarks ≠ your ERP. Internal approval flows and permission popups are where these models still fail.

How I'd evaluate it: pick one task you already owe someone this week, write explicit acceptance criteria (what counts as done, what must not happen), run it, then record four numbers — time to completion, manual corrections, quality vs. the criteria, actual token spend. If corrections don't go up while cost drops, it's a keeper for that task class. If it breaks on complex navigation and permission dialogs, cheaper doesn't help.

Curious: for those running computer-use agents in production, what's actually been the blocker — model capability, or the cost of the verification loop around it?

Hi everyone, I maintain sift-light, an open-source local project search and source-inspection tool for AI coding agents. It offers MCP and native integrations, returning bounded results so agents can inspect relevant code.

We just released 1.1.2-1. A contributor discovered that enabling tools in our Pi integration could change the beginning of the system prompt and reduce prompt-cache reuse. This update keeps that prefix stable and preserves search guidance when another extension supplies the system prompt. You need Pi 0.86.0 or newer.

We also added DeepSeek Harness 0.2.1-rc.3 support, including a native search tool and search-policy integration. The cache fix is specific to our Pi integration; behavior in other clients depends on their own prompt and tool handling.

Thanks to the contributor of PR #123 for identifying the issue and helping us fix it. If you try the update, feedback and reproducible bug reports are welcome.

GitHub: https://github.com/lightsifter/sift-light Release notes: https://github.com/lightsifter/sift-light/releases/tag/v1.1.2-1 X: https://x.com/Bryang168

SOURCE INTEGRITY: [ PRIORITY ]
AUTHORSHIP: [ HUMAN ]
INTERPRETATION: [ PROVISIONAL ]
EVIDENCE: [ REQUIRED WHERE RELEVANT ]
DISAGREEMENT: [ PERMITTED ]
CORRECTION: [ ENABLED ]
FRAMEWORK: [ REPLACEABLE ]
FINAL AUTHORITY: [ NOT CLAIMED ]

ONE SHARED LANGUAGE.
MANY PERSPECTIVES.

> _

I've been working on RAG and agent memory, and the recurring problem is trust. An agent saves something it learned, and later nobody can say where it came from, whether it is still true, or what it believed at an earlier date. We're building an open source Python library for this: OntoGr Agent Memory (https://github.com/ontogr/ontogr-agent-memory).

- Grounded ingestion and extraction: Messages, documents, tool outputs, events, and record rows become episodes. Entities and facts are extracted in two separate passes, and every fact carries a verbatim quote from its episode.

- Per-tenant ontology: Each tenant defines the entity and relation types it allows. A model can propose additions, but a person approves every change.

- Reversible entity resolution: It uses the cheapest evidence first and asks a model only about ambiguous pairs. Every merge can be undone.

- Two time axes: Valid time and system time let a read ask what was true on a date, or what the system believed on that date. A new value closes the old version instead of overwriting it.

- Contradiction rulings: Rules, an optional model judge, and a person's decision settle conflicts, and the person's decision overrides both. A failed judge call is never stored as "no conflict".

- Traceable and auditable: Every fact traces back to a quote and an episode, and every temporal write goes into a hash-chained ledger. Per-tenant grants, an audit log, previewed and resumable forget and erase, and deterministic export are built in.

- Four-lane retrieval: Vector, keyword, entity, and graph lanes are fused with reciprocal rank fusion. The result is a token-budgeted context block that reports which lanes failed.

- Fits your stack: It runs on FalkorDB or Neo4j, with pgvector or Postgres if you want them. A background consolidation job deduplicates, summarizes, scores, and archives. You bring your own LLM and embedder.

Repo: https://github.com/ontogr/ontogr-agent-memory

I'd like feedback on the time model and on which benchmarks you'd want to see first.

hey — i made a video editor that has no gui and gets driven entirely by ai agents over mcp, and i want to talk about the angle that's different now: titles, colour grade and particles are all just tool calls, and the agent can render a single frame to visually check its own work before exporting the whole thing.

it's called kimo. free, open-source (mit), and it's basically one 15 mb cpu-only rust binary that'll run on a 2 gb box. no tiling ui, no mouse, no timeline to point at — the coding agent (codex, cursor, opencode or whatever mcp client you're on) calls operations directly: cut, trim, keyframe, titles and captions, colour grade, tracking, particles, audio, export. and the bit i'm most proud of right now is that the agent can ask it to render a frame and look at it to verify the grade, the titles, the particles — that feedback loop is what actually makes this usable instead of just another ffmpeg wrapper.

built it myself, i'm a college student. i've used it to make a few videos end-to-end from an agent but i know it's rough — the tracking isn't quite there on fast motion, the particle system is barebones, captions positioning is manual, and the docs are thin. i'd rather hear what actually breaks for people than pretend it's polished.

if you want to try it and tell me what falls apart: https://getkimo.tech https://github.com/naman-sharma12345/kimo

thanks in advance, and yeah i'll be around to answer questions (but please tell me what broke rather than just saying it's cool, i actually need that).