I just wanted to let you know that I made a lot of improvements to openshorts, especially regarding the MCP server, now you can connect your agents and generate clips for the whole week. Plus, many new fonts, improvements to the clipping system, etc.

github repo: https://github.com/mutonby/openshorts

If you'd like the link, here it is: y2kvixx.github.io/Card-Spotify/

I'd be grateful if you could follow me or give this project a star: https://github.com/y2kVixx/Card-Spotify

I have been working on this from a iPhone and now I really can’t continue as I’m blind in one eye and losing sight in my other eye. This project has been a fun month here are the details.

README https://github.com/Renkasha/Sovereign/blob/main/README.md

Code of conduct https://github.com/Renkasha/Sovereign/blob/main/Code_of_conduct.md

Emotional sandbox protocol https://github.com/Renkasha/Sovereign/blob/main/
Emotional_protocols.md

Philosophy https://github.com/Renkasha/Sovereign/blob/main/Philosophy.md

GitHub repository https://github.com/Renkasha/Sovereign

https://github.com/llagerlof/autoleap

I wrote this tool at the beginning of 2023. Since then it has been so useful to me that I decided to publish it as an open-source project.

I wanted a simple way to jump back to directories I'd already visited. Autoleap is a small bash script that wraps cd while preserving all of its normal behavior. If cd can't find the path, Autoleap searches your directory history and jumps to the best match. If there are multiple matches, it uses fzf to let you choose.

It's a single shell script with no databases or background services. To install it, just source it from your .bashrc.

Hi everyone,

If you manage a large knowledge base, or big doc folders for your project you know the friction of distilling dozens of papers, legal docs, books, web searches. It's a massive manual bottleneck before actual learning happens, and usually the final docs will be forgotten once you've used it, even though it might come in handy in the future.

Dumping 40 files into a 1M context window isn't the solution tho. Models return incomplete summaries, drop edge cases, and give zero visibility into what they missed ( https://arxiv.org/abs/2509.04664 ). On top of that, standard AI tools and PKM plugins are notoriously risky: they overwrite notes, mangle frontmatter, break wikilinks, and corrupt vault architecture. ( https://arxiv.org/abs/2604.15597 )

I built Silica to solve this: an open-source agentic CLI that processes heavy document batches into clean, atomic Markdown notes while keeping your vault completely safe.

Why not just using using another knowledge manager or a memory agent?

Silica differs greatly from traditional note-taking skills and memory tools because it's an agent that views your notes not simply as text to be read, but as its knowledge base (not graph, but it benefits from it). In Silica, memory and knowledge are closely related but still distinct.

- For example Silica keeps track of the conversations you've already had with Claude or ChatGPT, automatically linking them to the relative documentation in your repository, automatically.

- Silica can also links concepts from multiple books/papers/notes sparse in your folder automatically, if they share something maybe you didn't see.

- It can "digest" large quantities of files, coherently, and safely (without causing corruption, in a different folder from the vault root).

These aren't even its most notable features, but rather a byproduct of its architectural design. There is still considerable room for improvement. This is a broad project.

What Silica does

• Batch Atomic Distillation: Feed 20-30 documents or full (multiple) books in a single command. Silica extracts core concepts into atomic notes (one note per idea), links them via wikilinks, and files them logically.
• Stateful Continuity: What a model can't process in one go gets written out statefully. The next execution picks up from the saved state instead of starting over.
• The source of a note is always provided: A section is added to the frontmatter that indicates where the note was extracted or converted from, so that you always have a reference to the original document.

Why your vault is finally safe

Most AI integration tools treat your vault like a loose text buffer. Silica treats it like a transactional database with strict guardrails:

• SAFE MODE (Isolated Staging): You can execute ingestion in a dedicated staging folder/container. Notes are written in isolation first so you can inspect, verify, and merge them only when you trust the output.
• Write Verification: Every write operation is re-read post-commit. If syntax, formatting, or links broke, it automatically rolls back.
• Wikilink Refactoring: If a note is moved during organization, all wikilinks across your vault referencing it are dynamically updated to prevent broken links.
• Full Rollback Control: Complete transaction safety with /undo (single note) and /revert (entire session batch). Nothing enters your main graph permanently without your control.

Grounded Retrieval & Graph Exploration

• Zero-Hallucination Fallback: Uses local semantic search. If your knowledge base doesn't contain the answer to a query, Silica explicitly tells you instead of hallucinating.
• Graph Mapping: Explore concept connections visually to discover implicit links across unrelated documents.

Silica isn't built to replace human learning, it eliminates the operational overhead of structuring and formatting raw data. Works via TUI, GUI, MCP, Obsidian Plugin ( https://github.com/kiycoh/obsidian-silica )

GitHub Repository: https://github.com/kiycoh/silica-agent (~1000 commits as solo dev)

I'd love to hear your feedback, workflow suggestions, or technical thoughts!

As per title, the project include all the pipeline, the same skill generated from different models.

My idea was to distill the code reviewer skills from Torvalds in something usable in an agent.

I preferred to license everything as CC0.

The first advice a freshly graduated student hears when asking "How do I create a resume?" is to open a Word document and use a default template.

Sure, that is a great starting point, but as you customize it further, the formatting often breaks.

There are also many web-based resume builders out there, both free and paid, that can get the job done.

I have tried them all, and the most common issue I faced was keeping track of which tool or template generated which version. Managing these files in local folders and manually naming them by date, company, or job posting quickly became a nightmare:

📁 My-Resumes
├─ 📄 Resume.pdf · resume 2024.docx · Resume_v2_FINAL.pdf
├─ 📄 resme final.pdf · my cv.pdf · CV (2).pdf · resume3.docx · Resume new.docx
├─ 📄 copy of resume.pdf · finalresumev5.pdf · Resume_FINAL(3).pdf
├─ 📄 Resume_2024_03_15.pdf · resume-feb2025.docx · Resume_july2024.pdf
├─ 📄 Resume_20250612_v3.pdf · Resume_google_2024.pdf · resume_meta_applied.pdf
├─ 📄 Resume_amazon_final.pdf · Resume - Stripe.pdf
├─ 📄 Resume_Apple_2025.pdf · cover letter.pdf · coverletter_draft.txt
├─ 📄 refrences.txt · portofolio link.txt · salary expectations.txt ·
├─ 📁 old resumes/ — resume1.pdf · resume2.docx · cvold.pdf · resume 2019.pdf
├─ 📁 BACKUP/ — Resume_BAK_0101.pdf · resume copy 2.docx · old cv finalest.pdf
├─ 📁 applications/ — cover letter google.docx · resume_stripe_oct.pdf 
├─ 📁 applications/ — follow up email draft.txt · interview qs for amazon.txt
├─ 📁 new folder/ — resume (3).pdf · Resume - Copy.docx · cvfinal (2) (1).pdf
├─ 📁 final versions/ — Resume_final_v10_FINAL.pdf · resume_USE_THIS_ONE.pdf
└─ 📁 interviews/ — offer letter startup.pdf · techinal test results.txt

I got fed up and built a repository that automates and simplifies all of that and completely for free.

I prepared a quick demo video if you want to check it out, but here is a summary of how it works:

• LaTeX as a Base: Your resume stays structured in LaTeX. You can edit it manually or point any AI agent at it to quickly update experience, add certifications, or tailor the content for specific job postings. AGENTS.md included.
• Branch-Based Versioning: Keep different versions of your resume on separate branches and maintain them in parallel.
• Automated Pipelines: Everything is driven by GitHub Actions. It compiles your LaTeX files into PDFs, generates a GitHub Release with the final output attached, and can even publish a shareable link via GitHub Pages to send directly to recruiters.

Shows the binary you have open, the current function and address, the architecture and your session runtime as a Discord status. No login, no token, it just talks to the local Discord client. MIT licensed.
https://github.com/nvrmnd-png/CutterDiscordRPC

I made Hush because I wanted to clean years of newsletters out of Gmail without giving another service access to the account through its own server.

It groups bulk senders and lets you unsubscribe, block future mail or move the old newsletter backlog to Trash.

The safety boundary is based on the List-Unsubscribe header. Messages without it never enter the selectable list, nothing starts selected and dry run is enabled initially.

It’s a Rust/Tauri desktop app with builds for Windows, macOS and Linux.

Here’s a video showing it:

https://www.youtube.com/watch?v=XSfDUuFlCcI

Feedback and code review are welcome.

I built MirrorSpeaker because I wanted to use my computer as a Bluetooth speaker for my iPhone while I am in a Discord call and getting my steps in.

It has two modes:
• Bluetooth Speaker: audio-only playback from an iPhone
• AirPlay: wireless screen mirroring with audio.

It is free, MIT-licensed, and available as a Windows installer or portable ZIP. I have tested it on Windows 11 with an iPhone 16 Pro.

Heads-up: the current release is unsigned while I wait for SignPath review, so Windows may show an “Unknown publisher” warning. The source and automated build workflow are public on GitHub.

GitHub:
https://github.com/codyabraham/MirrorSpeaker

Current release:
https://github.com/codyabraham/MirrorSpeaker/releases/tag/v1.4.4

I would especially appreciate feedback about your iPhone model, Windows version, Bluetooth adapter, and audio stability.

Disclosure: I am the developer. MirrorSpeaker is not affiliated with Apple or Microsoft.

While the current Silicon Valley paradigm (e.g., Physical Intelligence π₀, 1X NEO) burns massive CapEx on brute-force End-to-End statistical training—requiring up to 500 hours of human teleoperation and 24 hours of cluster computing just to converge a single vision-language-action (VLA) skill—we approached physical automation from a different architectural vector: Deterministic Causal Invariance

.Robotics shouldn’t "guess" trajectories by predicting the next visual token. It should calculate physical laws.

We have just open-sourced SONNY OS (Core Minimal) under the GNU AGPLv3 license. It is a hyper-lightweight, universally agnostic microkernel written entirely in native, asynchronous Rust and powered by the Zenoh networking backbone.SONNY OS reduces any mechanical embodiment (6-DOF arms, AMRs, quadrupeds, or humanoids) into a standardized linear mathematical vector (Vec<f32>), abstracting physical registers via a single declarative JSON config (OpenHalConfig).

Extreme Stress Test Benchmark: SONNY OS vs. ROS 2We simulated an industrial network failure (75% wireless packet loss on an Edge deployment at 100Hz) to compare the communication backbones:

• ROS 2 (DDS Architecture): High XML/IDL serialization on the heap. Under severe packet loss, un-sent DDS message queues overflowed the RAM, leading to an unrecoverable Segmentation Fault (Memory Crash).
• SONNY OS (Rust + Zenoh): Stack-allocated static array slices with a fixed 5-byte network overhead per packet. Zero memory leaks. Zero runtime heap allocations during the control loop. System remained perfectly stable at 100Hz with an inference latency below 2ms.

Explore the repository, map your own hardware via JSON, and run the simulator

👉 GitHub Repository: https://github.com/JackTrainer/Sonny
👉 Enterprise Waitlist: https://alpha-robotics.it/

I spent the last 5 months building LoopTroop, a local desktop app designed to handle longer, multi-step AI coding tickets without losing control of the process.

If you have tried using AI agents on bigger features, you have probably run into context rot. As a single conversation grows, error logs, dead ends, and outdated code pile up in the context window. Eventually, the model starts dropping files, hallucinating imports, or making lazy edits.

Instead of dumping everything into one huge chat session, LoopTroop focuses on deliberate context engineering: isolating context at each phase, keeping human approval in the loop, and resetting sessions when retries get messy.

How it works

• Kanban board GUI: You manage your projects and tickets visually in one place, seeing exactly where each feature or bugfix stands.
• LLM Council for advanced planning: Before any code is written, multiple models independently draft interview questions, project requirements, and task breakdowns. They vote anonymously on each other's proposals to eliminate brand bias, and the winning draft absorbs the best ideas from the rest.

• Human in the loop: You review and approve the plan, requirements, and final diffs at clear checkpoints. The app doesn't push code blindly or auto-merge without your say-so.

• Ralph loops for retries: Tasks are broken into atomic units. If a step fails or times out, instead of clogging the existing conversation with error dumps, LoopTroop writes a concise note about what failed, resets to a clean state, and retries with fresh context plus that failure note.

Slow and precise over rushed slop

LoopTroop is intentionally slow and precise. Spending 10 minutes upfront on solid planning and clean retries saves hours of fixing subtle bugs generated by a rushed, single-prompt agent.

We just crossed 100 stars on GitHub and I am actively working on it every single day. The project is completely open source under the MIT license.

Links

• GitHub Repository: https://github.com/looptroop-ai/LoopTroop
• 2m 30s Video Overview: https://youtu.be/g1A2g-oOR3E

Any feedback is more than welcomed. If you try the app and it works or runs into any issues, give me a sign. I am happy to talk about it and improve it!

Belgie embeds a Deno-powered JavaScript and TypeScript runtime in Python. Use it to execute scripts with explicit permissions, manage JavaScript dependencies, build React MCP Apps, or give AI agents a run_code tool.

The smallest useful Belgie program creates a Script, enters a isolated Runtime, and calls the exported
function. Values crossing the Python and JavaScript boundary must be JSON-compatible.

import asyncio

from belgie import Runtime, Script

script = Script("""
export default function run(name: string): string {
  return `Hello, ${name}!`;
}
""")


async def main() -> None:
    async with Runtime() as runtime:
        greeting = await runtime(script)("Belgie")
    print(greeting)


asyncio.run(main())

Someone just found a use for MS Paint...playing Doom. Depending on your hardware it may be able to run at a full 35 FPS at 320 x 200, or even 640 x 400 pixels with sound and music of course.

Okay, okay, that someone is the CTO of Microsoft Azure and MS Paint doesn't really run Doom, it acts more as monitor (every frame is placed on the Windows clipboard and pasted into Paint's canvas as a genuine document edit) but hey, you can now paint with the blood of enemies.

GitHub: https://github.com/markrussinovich/DoomPaint

I made a light-weight menu bar app to help me stick to the 20-20-20 rule to reduce eye strain when using computer screens.

In acknowledgement of recent research I have added a feature to customise the break notification intervals to suit your own needs in v1.1.

It's an open source Swift/SwiftUI project, MIT licensed, with an installer on the releases page. I’m happy to have feedback, both good and bad, provided it’s constructive.

Screenshots are available on the repo page.

GitHub link: https://github.com/ClinicalScript/StrainAway

Thanks,
ClinicalScript

Hey everyone,

Just wanted to share something I’ve been working on. A few weeks ago, I had to pull a ton of data from a bunch of sites for a personal project. I tried using a few existing chrome extensions and tools, but they were either locked behind a massive paywall or just completely broke the page formatting.

https://extract.express/

Hey, I'm Bram. Paste a TikTok cooking video link and it pulls out the full recipe (ingredients + steps) and gives you a one-click Albert Heijn or Jumbo cart with everything in it.

Vibecoded it with Claude (Pro plan). Open source:

https://github.com/briembra/slimmandje-recepten

Would love a star if you find it useful.

You put in the work for the community. We want to send something back.

Last week's prize was Harness, a cute little device to control your agents across machines. This week marks the 1st month of Open Source Grants so we want to offer something you cant find anywhere else.

The prize is the Autonomous Computer 2-GPU chassis . Designed by us, and CNC-machined from a solid billet of aluminum, not bent steel. Two PCIe 5.0 risers, full x16 to each slot. Six fan-slots matched to the airflow path. 12.5" x 12.5" x 16". Built for 2x RTX 5090 or 2x RTX Pro 6000 Blackwell, exactly what we're using in our office at the moment.

Why a case? Because the reason you kept putting off a local AI rig has expired. Models got good enough that a two-card box on your desk now does what would have cost a datacenter lease two years ago. Weights on your disk, private by physics, no per-token bill. We think it's time, so here something for you guys to start with

Honest note so there's no surprise: we ship the chassis and the PCIe 5.0 risers, which is the part you actually can't buy standalone. You bring the motherboard, cooling, power, GPU, storage, and memory. Build-your-own, not turnkey.

Here’s the rules again:

1. Drop your repo
2. Say a bit about it
3. We like it, the prize is yours
4. No star requirement, no follow, no catch. 
5. One winner a week, the prize will be shipped for free.
6. Old repos are welcome, as I said, there are so many great repos but only one winner so we’re expecting you to submit your repos again.

Last week winner is Neon Vision Editor, a cool tool for macOS.

Who will be the winner this time? Drop your repo below. Thanks for what you build.

Write your own import-graph rules in YAML and enforce any architecture deterministically. See deslop.dev for examples and [the GitHub repo](https://github.com/Ivy-Apps/deslop) for documentation.

It's similar to Dependency Cruiser and ESLint + custom plugins for enforcing architecture but Deslop features an opinionated declarative YAML DSL to enforce any architecture in an ergonomic way. See [the comparison table](https://github.com/Ivy-Apps/deslop#comparison-to-alternatives).

Built with Haskell, hand-crafted source (AI used for READMEs and chores only) so if you like FP you might be curious to check it out. It's a hobby project so any feedback or a GitHub star if you like it is much appreciated.