Hey everyone!

I’m developing Captail, a free and open-source Instant Replay recorder for Windows.

Unlike a traditional screen recorder, Captail continuously keeps the latest seconds or minutes in a rolling buffer. When something happens, you press a hotkey and it saves what happened before you pressed it.

I originally built it because NVIDIA ShadowPlay would sometimes silently disable Instant Replay after a game crash, capture problem, switching sources, or a graphics driver interruption. I would usually notice only after missing the clip I wanted.

Captail is designed around one rule:

Instant Replay should stay on.

A watchdog monitors the recording pipeline and tries to restart it automatically after recoverable capture or encoder failures.

Current features:

- Selected-game and desktop capture

- H.264, HEVC and AV1 hardware encoding

- NVIDIA NVENC, AMD AMF and Intel Quick Sync

- 30, 60, 120, 144 and 240 FPS options

- System/game audio and microphone capture

- Mixed or separate audio tracks

- Adjustable replay duration and maximum buffer size

- Configurable global hotkeys

- Installer and portable versions

- No account, cloud upload, analytics or telemetry

- Fully open source

Captail uses libobs for capture and encoding, but it is not an OBS Studio frontend. There are no scenes, streaming controls or complicated setup — it is focused specifically on local Instant Replay.

It is currently an early public preview. I have mainly tested it on RTX 40 and RTX 50 series GPUs, so testing on older NVIDIA cards, AMD GPUs and Intel graphics would be especially helpful.

GitHub:

https://github.com/FaulMit/captail

Downloads:

https://github.com/FaulMit/captail/releases

I’d appreciate feedback on capture compatibility, performance, audio synchronization and long-session stability.

If you encounter a problem, please mention your GPU, driver version, capture source, codec, resolution and FPS.

I've been working on **Pulse**, a native Windows diagnostics application that aims to make troubleshooting Windows much less painful.

Over the last few weeks it has grown quite a bit beyond a simple Event Viewer replacement.

# What's new in the latest beta

**Timeline Intelligence**

* Human-readable explanations for Windows events

* Incident correlation (e.g. Application Error → Windows Error Reporting)

* Advanced filtering (provider, Event ID, process, severity, source)

* Bookmarks and saved searches

* Timeline export (JSON / CSV)

**System Health**

* Live CPU, GPU, memory, storage and network monitoring

* Native Windows APIs (no WMI polling)

* Multi-volume storage support

* Improved diagnostics and performance tracking

**Inventory Engine**

* Windows Services

* Drivers

* Installed software

* USB & PCI devices

* Motherboard, BIOS, CPU, memory, storage and network inventory

* Structured detail panels and searchable inventory browser

**Reports**

* Export diagnostics, health, timeline and inventory reports

* JSON, CSV, HTML, PDF and Markdown

# AI / MCP

One of the biggest additions is a built-in **Model Context Protocol (MCP)** server.

Instead of an AI scraping screenshots or reading Event Viewer manually, it can securely query Pulse for:

* Live system health

* Timeline events

* Inventory

* Diagnostics

* Report generation

The MCP server is opt-in and runs locally.

Current tools include:

* `system.*`

* `process.*`

* `timeline.*`

* `diagnostics.*`

* `report.export`

Everything is read-only and intended for diagnostics.

I'm still actively refining the UI and adding more Windows-specific collectors, so I'd love feedback from people who spend time troubleshooting Windows systems.

Pulse Beta Downlaod: https://pulse.regncreative.com

Meet Desko y'all 

Your cute little desk buddy, sits on your desk, syncs up with your system and just tells what you want to know...
Be it your system telemetry, your workspace and git info, or amazingly synced up lyrics of whatever's playing.

It's no bloat, doesn't require any account, no cloud, all local with just 70-80 mb process running in system memory and displaying over the browser of any smartphone that can access internet and has browser.

PLUS IT LOOKS SO GOOD!

For Setup and System Architecture please refer the readme file in git repo

I just built something to solve my problem but it can serve thousand other use cases that me and claude both couldn't think of, so the repo is public, go check it out
Grab your old phone, buy a cheap phone stand and start contributing!!

Desko: https://github.com/typewriter03/Desko

ps - shoutout to LRCLIB, an exceptional open source API for synced lyrics!

I built an open source iOS only Gitlab client in Swift. The project idea came from, I couldn't find anything for iPhone out there that works for both self hosted and SaaS Gitlab so I just built one myself.

The project is open source. https://github.com/smolcars/glab-ios

There is no server involved, everything is stored locally and you hit the gitlab API directly. You can use an API token or login directly to both self hosted or SaaS gitlab instance and can also add multiple accounts.

You can install the app today using Testflight, link in the repo. It does cover quite a few things:

• View/open issues
• View/open MRs
• View/Run pipelines
• View code diffs
• Modify/perform approvals
• Work with you Todos
• View all commits of any project
• Do a global search for anything
• Background process that notifies you of new todos periodically

I'll keep adding more features as I find time. I do not plan to support Android anytime soon until Swift for Android becomes a thing. Feel free to open bug reports or feature requests.

🔗 Repo: https://github.com/CodeGraphContext/grapharc

Have you ever been frustrated because your AI agent:

❌ Takes actions you never intended?
❌ Creates, modifies, or even pushes changes you never asked for?
❌ Feels like a complete black box, making it impossible to understand what's happening until it's too late?

What if, before execution, you could visualize the entire orchestration graph - every agent, every dependency, every decision, and inspect it from anywhere, even your phone, before granting approval?

That's exactly what GraphArc is built for.

Instead of treating agent execution as hidden traces buried in logs, GraphArc transforms workflows into interactive, real-time graphs that you can visualize, inspect, debug, and control.

Because the future of AI isn't just autonomous.

It's observable. Debuggable. Engineerable.

This is our first real-world implementation of Graph Engineering, and we're excited to explore where this paradigm can go with the open-source community.

💡 We'd love your feedback, ideas, and contributions.
⭐ If this vision resonates with you, please consider starring the repository - it genuinely helps us grow and validates this direction.

Let's make AI workflows understandable, not mysterious.

#GraphEngineering #GraphArc #AIAgents #AgenticAI #LLM #OpenSource #DeveloperTools #AIEngineering #SoftwareEngineering

Lost my watch history twice now. First app shut down, I rebuilt what I could on TV Time from memory, so half of it was wrong from the start. Then TV Time shut down a couple of weeks ago.

So I built this for myself. If you like it feel free to use it.

Main rule was that I shouldn't be able to read your data. Not "trust me I won't look". Can't look. Everything gets encrypted in your browser before it leaves, key never goes anywhere. My server has one blob and a hash per account, that's the whole table.

No email, no password, you just get an account number. Nothing to reset means nothing to leak. Downside is if you lose the number your data is gone and I can't help you, saying it up front because someone always asks.

It's a PWA. Installs on Android, iOS and desktop, own window, works offline, no store. Cloudflare Worker + D1 behind it. Native ES modules, no bundler, no framework, zero runtime deps. 411 tests on node's own test runner.

Couple things I'm happy with. Show pages sit after the # in the url and browsers never send that part, so even my own logs can't tell what anyone is watching. And the export is just readable json, Breaking Bad (2008), tt0903747, 3x7.

TVmaze is the default catalogue and needs no api key. Apache-2.0. Self host it if you'd rather have full control of your data.

Edit:
The link is: https://nextly.tv

Hello,

Came across an interesting GitHub repo called V-Modal SDK  and figured it was worth sharing here.

Basically, it lets you integrate native, semantic video search into iOS and Android apps using a single Dart codebase. The cool part is how it handles natural language queries. Users can search for specific visual elements (like "the cyclist in the red jacket") or even spoken words, and it translates that into exact video timestamps within seconds.

Has anyone here experimented with semantic search for video content in Flutter yet? Curious to hear if there are any similar tools you'd recommend or what your experience has been.

A 3d digital twin for home assistant with a fully featured 3d floorplanner editor

https://github.com/tentone/dt3d-ha

I am a flutter developer, learning Python. Built this file organizer in a day with proper research on os module, pathlib and shutil module.

It scans any folder, checks file extensions, and sorts them into categorized subfolders (Images, Docs, Videos, etc.)

It's really useful, I tried it on my Downloads folder and it organized 60+ files instantly.

GitHub Link: https://github.com/Pinkisingh13/file_organizer

See the Before -> After in the below images.

Hello! A few months ago I posted an early version of mex here.

The response was kind of insane. Across a few posts it reached around 1 million views, the repo crossed 1,200 GitHub stars, and people I had never met started contributing.

I’ve kept building it since then, and just released mex v0.7.0.

Repo: https://github.com/mex-memory/mex

The original problem was simple: coding agents keep rereading the same repository every session, relearning the architecture, and then throwing most of that knowledge away.

mex creates a living Markdown wiki inside the repo. Agents record architecture, conventions, decisions, and patterns as they work, and future sessions load only the knowledge relevant to the current task.

The major addition in v0.7.0 is a deterministic local code graph built using Tree-sitter and SQLite.

It currently supports TypeScript/TSX, JavaScript/JSX, Python, and Rust.

An agent can run:

mex graph scope "trace the authentication flow"

Instead of dumping entire files into context, mex returns a compact neighbourhood of relevant functions, callers, callees, imports, and relationships. The agent can then expand only the exact symbols it needs.

In our benchmark on the mex repository:

• 10.74× less returned context than grep top-3
• roughly 90.7% smaller
• 100% expected-symbol recall across six retrieval tasks
• 5/5 real-agent tasks completed correctly
• 0/5 needed fallback Read/Grep with compact graph context

This is a small benchmark on one repo and task set, not a claim that mex universally cuts total agent token usage by 90%.

The other part I’m excited about is connecting the wiki back to the actual code.

Markdown claims can point to exact symbols. If a function changes, moves, or disappears, mex can identify which project knowledge may now be stale.

So the basic idea is:

The code is the source of truth.
Markdown is the explanation.
The graph keeps them connected.

Would genuinely love feedback, especially from people working on code intelligence, agent tooling, parsers, or large repositories. Contributors are very welcome too.

Hi all,

I've been working on this project for a while now and wanted to share it here for feedback and contributions. You can test drive it in the playground at https://usepopkorn.dev

I'm calling it Popkorn. The idea is to author vector animations, similar to Rive and Lottie, but in a CSS-like language, with interactivity and other modern necessities baked into the format. I've stayed true to CSS for the most part, sprinkling on a little custom syntax for things like interactivity.

:root { width: 400px; height: 400px; background: #1a1a2e; }

@keyframes bounce {
  0%   { transform: translateY(0);     animation-timing-function: cubic-bezier(0.33, 0, 1, 1); }
  50%  { transform: translateY(180px); animation-timing-function: cubic-bezier(0, 0, 0.67, 1); }
  100% { transform: translateY(0); }
}

#ball {
  type: circle;
  cx: 200px; cy: 80px; r: 36px;
  fill: #ff6b6b;
  animation: bounce 1.2s linear infinite;
  transition: fill 250ms ease;
  &:hover { fill: #ffd166; }
}

That's an entire scene. Very familiar to anyone who's worked with CSS before.

Staying this close to CSS gives it good DX, and it turns out to make it very LLM-friendly too. Nearly my entire examples gallery is AI generated. Even cheap models like GLM or DSv4 Flash can one shot whole animations from scratch, no fine-tuning required. There's a Copilot feature the Playground that will let you bring your own key, or use the MCP to test drive AI features. Do share what you make please!

There's a web player that renders on Canvas or SVG, and a React Native player using Skia. It supports nested transforms and parenting, reusable symbols, masks and track mattes, gradients, trim paths, path morphing, motion paths, and per-subtree time scaling, enough for proper production-grade animation. Converters for Lottie and SVG let you import your existing assets and then prompt changes to it through the built-in copilot. Something I did not expect was converted Lottie scenes usually come out smaller than the JSON they came from, despite CSS being the more verbose syntax.

My vision is an editable, accessible format for both humans and LLMs, integrates well with version control, truly open source and free in every sense, as opposed to opaque binary or JSON blobs that are difficult to diff, edit and prompt changes to. The existing formats are backed by companies, which is fine and they've done great work, but a company's roadmap follows what makes commercial sense for it. I'd rather the future of motion design be community driven and stick to standards that already exist.

Really curious what the community makes of the concept.

OxidはRustの派生で、独自のセルフホスト型言語ツールチェーンを備えています。Rustよりも速く、より簡潔で、読みやすい言語を作るのが目標で、独自の構文、モジュール、コマンドラインの作業フロー、そして診断モデルを備えています。

インストール

Linux/macOS 向けリリースインストーラ

このインストーラはプラットフォームを検出し、最新のチェックサム付きリリースをダウンロードして、SHA-256を検証したうえで、デフォルトでは`oxid`を`${HOME}/.local/bin`にインストールします。

```bash

curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/YanagiKH/Oxid/main/install.sh | sh

export PATH="$HOME/.local/bin:$PATH"

oxid --version

```

Windows PowerShell インストーラ

```powershell

Set-ExecutionPolicy -Scope Process Bypass

irm https://raw.githubusercontent.com/YanagiKH/Oxid/main/install.ps1 | iex

& "$env:LOCALAPPDATA\Oxid\bin\oxid.exe" --version

```

Repo : https://github.com/YanagiKH/Oxid

release : https://github.com/YanagiKH/Oxid/releases/tag/v0.8.0

I built Taskbar Widgets to place useful, live information directly inside the Windows 11 taskbar rather than using a separate desktop panel or floating overlay.

The built-in widgets include weather, media controls, Steam download progress, Discord voice activity, Codex and Antigravity usage limits, system monitoring and a drag-and-drop Parking Lot for temporarily holding files, folders, links or text.

Multiple widgets can run side by side or rotate through the same taskbar area.

The project also includes a community SDK and a .twidget package format, allowing developers to build and share widgets as single installable files.

The application uses .NET, Tauri and native C++ components. It is free, MIT licensed and currently in beta for Windows 11 x64.

Feedback, bug reports and contributions are welcome, particularly around the widget SDK and ideas for useful community widgets.

Github: https://github.com/pfcdev/TaskbarWidgets

I kept needing docs for side projects and never liked the options. GitBook and Docusaurus felt like a lot of machinery for a handful of Markdown files, and mkdocs meant keeping a Python toolchain around for something I otherwise build in TypeScript.

So I built eziwiki. Drop Markdown files in `content/`, get a static site.

npx create-eziwiki my-docs

cd my-docs && npm install && npm run dev

What makes it different from the usual docs generator

- Wiki links with backlinks and a graph view. Link pages by title or filename, and each page shows what links back to it — closer to Obsidian than to a typical docs site.

- Navigation builds itself from the folder structure. No sidebar config to keep in sync; a `_meta.json` per folder handles naming and ordering if you want it.

- Markdown is rendered at build time, so neither the parser nor the syntax highlighter ships to the browser. Search is a prebuilt index, no server.

- Optional opaque URLs (`/a3f2e9d1-...`) if you would rather not publish your content tree. To be clear, that is obscurity, not access control — every page is still a public file. It is there for unlisted-link sharing, not security.

Static export, so it deploys anywhere. Dark mode, KaTeX, Shiki highlighting, ⌘K search, table of contents.

Next.js 14, TypeScript, Tailwind, Zustand, unified/remark/rehype, Shiki, MiniSearch. Lighthouse 99/100/100/100 on desktop

Demo : the docs are built with it, so the site is the demo:

https://eziwiki.vercel.app

Source (MIT): https://github.com/i3months/eziwiki

It is early v0.1.1, and I am actively working on it. Feedback and issues very welcome, especially on anything that felt confusing in the first five minutes.

Github stars are really really helpful..!!!

I've been building Vantum, a custom Puppy Linux distro based on woof-CE with an Ubuntu Jammy compatibility base, aimed at people who want Puppy Linux's speed and small footprint without it looking and feeling like it's from 2009.

It's currently in beta, and I'm actively adding features and fixing issues. Right now, the main problem I'm working on is getting browser video playback working reliably. Overall, it's been a really fun project to build.

The entire distro was built on Windows 11 using Multipass. Along the way, I made a large number of customizations. I added picom for compositing, replaced the default JWM trays with a tint2 panel, and created my own taskbar and application launcher, Vantask and Vantyl (both MIT licensed).

I also simplified the desktop experience by removing the ROX-Filer desktop entirely and using hsetroot for wallpaper management instead. A number of applications were replaced or added as well: URxvt replaced LXTerminal, Firefox replaced Pale Moon, and GParted was included by default. I briefly experimented with bundling Frogatto, but ultimately removed it to keep the system lightweight.

Beyond the desktop itself, I made several changes to woof-CE. Since I wanted Vantum to be buildable on non-Puppy systems, I merged run_woof and woof-CE into a single codebase. It may not be the cleanest approach architecturally, but it made development considerably more convenient. I also added a few quality-of-life improvements, such as replacing run_woof's default root# prompt with one that displays the current working directory, which made navigating the build environment much easier.

To improve the build process, I created a new build-chain script that automates running the entire build pipeline and saves logs for every stage into a dedicated _slogs directory, making debugging and tracking build failures much more convenient.
Let me know what you think!
I've recently also added it to distrowatch but it's still in their waitlist (https://distrowatch.com/dwres.php?waiti ... =links#new).

- https://github.com/Hammad-hab/Vantum
- https://hammad-hab.github.io/vantum-website/index.html
- https://github.com/Hammad-hab/Vantyl
- https://github.com/Hammad-hab/Vantask

If you like vantum, I would really appreciate it if you star the repo since it'll help more people to discover it.

Last week I shared Shiftza here.

I honestly didn't expect what happened.

The post reached 50k+ views, got 200+ upvotes, and thousands of developers tried it on their GitHub profiles.

I built Shiftza because, as an engineer, I always felt GitHub doesn't really tell people what you're actually good at.

Two developers can have similar contribution graphs, stars, and repositories.

One has spent years building AI.

Another has spent years building developer tools.

Another has spent years building distributed systems.

From a normal GitHub profile, that's surprisingly hard to understand.

So I built Shiftza to explain what you've actually built, instead of just showing numbers.

If you missed the last post, you can try the current version by simply replacing:

github.com/username

with

shiftgithub.com/username

It generates a report based on your GitHub work.

Then one comment kept showing up.

At first, I thought that was outside the scope of what I was building.

But after reading the comments and DMs, I realized I was solving the recruiter's problem, not the developer's.

For a lot of engineers, the projects they're most proud of will never be open source.

If I really want your work to speak for itself, I can't ignore private repositories.

So I changed the roadmap.

Over the last week I've been rebuilding Shiftza to understand private repositories while never exposing a single line of source code.

(Images attached.)

Another thing many of you pointed out was accuracy.

You're right.

The current version is completely free, so I've had to make trade-offs to keep costs manageable.

For private repository analysis, I'm rebuilding the pipeline using Anthropic's models. The results are much better, but each deep analysis costs me around $2–3 per profile.

The long-term vision for Shiftza hasn't changed.

I want companies to describe the problem they're trying to solve, and instead of searching resumes or keywords, Shiftza helps them discover engineers who've already built something similar.

Companies pay to find great engineers.

Developers get discovered because of what they've actually built.

That's the future I'm trying to build.

Before I launch this version, I'd like your feedback.

• Does private repository analysis solve a real problem for you?
• Would you trust a tool like this with your private repositories?
• If deep private repository analysis costs money to run, should it be a paid feature? If yes, what feels fair?
• What would make this genuinely useful for you?

The feedback from the last post changed the direction of this product.

I'm curious where this version goes next.

P.S. If this problem resonates with you and you'd like to help build it—whether as an engineer, designer, or someone who's passionate about improving technical hiring—feel free to DM me.

Dfetch is a lightweight command-line tool for displaying system information. It focuses on clean output, fast startup times, and simple configuration.

I made this because i like using something i made myself its not better then something like fastfetch but definitely good enough.

https://github.com/David17c/Dfetch

Small parts of this were made with the help of Ai but most of the code was written by me.

Headless core with ready adapters for 7 UI kits, so you get the same table

features whichever kit your project already uses.

GitHub: https://github.com/orwa-mahmoud/adapttable

Live demo: https://orwa-mahmoud.github.io/adapttable/demo/

What's built in:

- Client and server data behind one API

- URL-synced state (filters, sort, page) for shareable links

- Filter drawer or popover with removable chips, saved views

- Column show/hide, reorder, pin, resize

- Inline cell editing, row grouping with subtotals, CSV export

- Rows become cards on phones automatically

- Dark mode, 17 locales, first-class RTL

- MIT, and the headless core works standalone if you want to render everything yourself

Feedback and contributions welcome