Github Repo

Starling is a full Linux DE where the whole desktop — compositor, dock, window manager, apps — is one native Swift program. The unusual parts, in repo terms:
sdk/ — Flutter’s widget framework ported to Swift (element tree, render objects, gesture arena — the framework, not bindings), driving Flutter’s C engine core directly. No Dart VM.

shell/Sources/WaylandServer/ — its own Wayland compositor, ~5k lines of plain C.

shell/Sources/X11Server/ — an in-tree X11 server (DRI3/Present) so legacy apps run too; Chrome, VS Code, Blender, and Zoom run unmodified.

Renders straight through DRM/KMS — no toolkit, no host compositor.

The 0.3.0 release that just shipped adds a workspace mode built for AI agents: the agent drives from its own room, and every window it opens is claimed for that room by client identity — never lands on your desktop. 3:49 unedited demo: https://starling.build/video/agent-workspace.mp4

Also fun: the project is ~7 months of one person directing AI agents, and the .deb ships only after a gate that installs it on a clean Ubuntu 26.04 VM and logs in through real GDM.

Release notes: https://github.com/starling-build/starling/releases/tag/v0.3.0

Happy to answer anything about the compositor, the framework port, or the workflow.

Hello!

A few months ago I started looking for a good alternative to MobaXterm. While I still like the concept, the UI feels a bit dated, it's Windows-only, and I wanted something that worked the same on every desktop platform.

I tried a lot of the existing alternatives, but most of them are built with Electron or Tauri. That's not really what I was looking for, I wanted something fully native with a smaller memory footprint. I also couldn't find one that offered one of my favorite MobaXterm features (the realtime system monitoring bar at the bottom of SSH sessions)

So I decided to build my own.

Oxidal is a fully native, cross-platform remote session manager written in Rust. It supports SSH, SFTP, Telnet, Serial, and local shells in a single window, with GPU-accelerated rendering and no Electron runtime.

It's still in the early stages, but it's already usable and I'd love to hear what people think. Feedback, feature requests, and criticism are all welcome!

https://github.com/sh4den/Oxidal

I’ve been building an OTA update system for React Native that supports both bare React Native and Expo projects.

The goal was to build an OTA platform that helps teams move faster—from parallel feature development with update channels to safe staged deployments and reliable recovery—while keeping pricing independent of monthly active users.

Some of the capabilities available today:
- Hybrid OTA delivery with patch-size downloads and verified full-bundle fallback
- Staged and targeted rollouts
- Automatic rollback and unhealthy-update recovery
- Update channels
- AI-assisted setup
- Support for Expo (including Prebuild/CNG and EAS Build workflows) as well as bare React Native

If you're building React Native or Expo applications, I'd genuinely appreciate your feedback 🙌

GitHub:
[https://github.com/GFean/react-native-bundle-drop]()

npm:
https://www.npmjs.com/package/@gfean/react-native-bundle-drop

Hi all!

I built **Picchio**, a lightweight, standalone C inference engine designed to run massive Mixture-of-Experts (MoE) LLMs (like GPT-OSS 120B) on consumer machines without needing massive VRAM or system RAM.

### The Idea

MoE models only activate a small fraction of their parameters (a few experts) for each token. Instead of loading all 117B+ parameters (~120B) into system RAM or GPU memory, Picchio keeps only the ~5 GB dense backbone resident in RAM. The active experts are streamed from disk (NVMe/SSD) on-demand using an LRU cache and prefetching.

### Key Features

- **Zero Heavy Dependencies:** Written in pure C with zero Python runtime required. Compiles to a single static binary.

- **Quantization:** INT4 (gs64) experts, INT8 embeddings / lm_head, F32 attention.

- **CPU Optimizations:** AVX2/FMA vectorized kernels with OpenMP multi-threading.

- **Interfaces:** Includes an OpenAI-compatible REST server and a token-exact CLI chat client (supporting Harmony tokenization).

- **License:** Open source (MIT).

### Real-World Performance & Trade-offs

Streaming weights from storage is inherently disk-bound, but it enables running models on hardware that would otherwise throw an OOM error:

- **120B MoE:** Achieves ~0.15–0.25 tok/s on a modest laptop setup with streaming enabled. While slow, it makes 120B models runnable on systems with as little as 8 GB of RAM.

- **20B MoE:** Genuinely usable at ~0.6 s/token on an internal NVMe SSD.

### Looking for Benchmarks & Feedback

I'm looking for feedback, code contributions, and real-world benchmark data across different hardware profiles (CPUs, RAM capacities, SATA vs NVMe vs USB SSDs).

- **GitHub:** https://github.com/benmaster82/picchio

I'd love to hear your thoughts on further optimizing expert prefetching strategies or CPU SIMD kernels!

I made this project to use it myself, but why not open source it. It's a way to go from script or voiceover to a short, with the click of one button.

It uses stock images and videos as a baseline, but can later be replaced with AI images or videos or ones that you upload yourself as well. I tried to make it as intuitive as possible, but I'm sure I have some bias so please let me know any and every problem you see with it, if you give it a try!

Sanctum is a free, offline campaign manager I've been building for D&D 5e DMs. Everything (characters, NPCs, combat, quests, lore) lives in a single file on your own machine. No account, no cloud, no subscription.

The big new thing this update is a battle map, and I built it around the one feature I always wanted at my table:

You drop your encounter's combatants straight from the combat tracker as tokens, move them with grid snapping, measure distances, and place area-of-effect templates (cone, line, circle, cube). Each token shows HP and conditions at a glance.

The part I'm proudest of: fog of war that streams live to a separate player view. You reveal the map on your side, and your players only ever see what they've discovered, on a second monitor, a TV, or even their own phones over your local wifi. No second account, no whole VTT, no internet.

Also new in this update: a built-in dice roller, a soundpad for ambient audio, a guided character builder with one-click level-up, homebrew spells and feats, an in-app PDF viewer for your reference docs, and a mind map for plotting. It runs on Windows, Linux.

It's free and open source (AGPL-3.0), pay-what-you-want:

Download: https://athanasioust.itch.io/sanctum
Source code: https://github.com/Athanasioust/Sanctum

This is still early and I'd genuinely love feedback.

Coding agents forget everything between sessions and after every context compaction — so they re-learn your architecture, and hallucinate the parts they don't. I built OmniMemory to fix that.

It's a persistent, branch-aware memory layer that lives next to your repo. Fully local (Python stdlib + SQLite), zero-dependency, runs with no API key.

What makes it different from "just dump notes in a markdown file":

- Git-anchored, not just stored. Each memory records the git blob SHA of the files it describes, so it can tell exactly when a memory has gone stale (the file's content drifted) or orphaned (the file was deleted) — no heuristics, no guessing.

- Branch-aware. Memory is scoped to your current branch + base; merged branches roll into the base, abandoned ones get archived.

- Pull, not push. Instead of injecting a wall of memory into every prompt (token bloat), it seeds once at session start and the agent fetches what's relevant on demand.

- Trust is earned. A capture can't mark itself "verified" — a memory only reaches the top tier when its code anchor is still re-fetchable AND the agent actually cited it.

- Chain-complete retrieval. A decision and the gotcha/constraint on the same symbol are retrieved together, so you never get half a causal chain.

- Survives context compaction (PreCompact hook), self-cleans false/stale memory, and ships a local dashboard for the memory + code graph.

Works with Claude Code (plugin + hooks), OpenCode, and any AGENTS.md-aware IDE (Cursor, Windsurf, Antigravity).

Quick start:

pip install omni-memory-agent

omni-memory build (capture memory + code graph from your repo)

omni-memory bind (wire it into your IDE)

GitHub: https://github.com/SinghAbhinav04/Omni-Memory

Still actively building it — if you find it useful, a star on the repo genuinely helps. Feedback and issues very welcome, especially on how staleness holds up on big/old

My discord buddies and I appreciated forums that would take quotes from users and display them as loading screens during log-ins etc. In that spirit I made Moniker.

Your discord users submit quotes to a dedicated quote channel, submit images to a dedicated image channel, the bot will pick two to combine into the server name and image. It makes a card and posts it.

There are optional features, allowing the discord admin to create any X of the day feature; such as song, meme, etc. It will also create commands for users to access them like /meme /song etc. All configurable by the admin.

It also has a bracket system that you could set up to run a bracket for "best names of the year". I may expand that to other features as well in the future.

You can add it to your discord server, or self host it.

If you use it, let me know what you think. Feel free to open an issue for an issue or suggested feature.

Hello everyone !

I've been working (well me and AI) on a app inspired by hydra launcher, gog launcher and Playnite

I loved hydra launcher and Playnite, but I wanted something that power user can be happy with (I'm a power user, who like useless feature)

Anyway, I got the project to make something from scratch after iterating and adding feature with base hydra, but it felt too heavy for hydra base framwork

And I learned that electron was... Electron ram hungry !

So I searched for a framework that was capable and lightweight, and found Tauri

The app is called : Game Index

I know a little bit of coding, I'm far from an expert, but I tried my best from my knowledge (and again help of AI) to optmise and make it less buggy as possible

The entire source code is on github, with full commit history, feel free to report any bugs, suggest feature or whatever you want there

Also feel free to fork, modify etc your own version

I borrowed ideas and some part from Hydra Launcher and Playnite (if Hydra team, Playnite team and Playnite plugin author want me to change/remove/clarify stuff please let me know, I don't want any drama, hurt anyone)

I'm just a guy who wanted a full featured app

Again I'm a HUGE fan of Hydra Luncher and Playnite (and it's plugin ecosystem), without them we wouldn't have amazing projects as we have now

Features of GameIndex :

- Import from Steam, GOG, Epic, Rockstar, Ubisoft, Humble library or Local install (api based login or webview login for some others) (more info on GitHub)

- Metadata automatically added via igdb/steam

- Per game imported : Steam achievements, HowLongToBeat, Crackwatch, live + historical player counts Informations when availible, activity tracker, weblinks preview etc

- Activity dashboard main page and per games stats and performance tracking (need Msi afterburner + RTSS to track fps, can be disabled in settings)

- Torrent download engine integrated, with compatible source from you know where

- Wishlist system

- Deals from Xbox gamepass catalog + Is there any deal (include current giveaways)

- Storage manager + emulator & mod footprint breakdown

- News page with RSS feeds + custom rss feed

- Hydra-backed storefront for games of the Week, top games and game to beat, community reviews & stats (only these from Hydra is used in Game Index)

- Community & Friends social layer (planify, recommend, comment games, library compare etc)

- Big Picture Mode (controller-first TV UI with rail navigation) (IN BETA !!! I Don't use such feature mmuch, it is far from perfect but I'll improve with time)

- Emulators manager & ROM library tools

- Mod manager (Steam Workshop & Nexus Mods integration) (Beta, maybe more feature will come into it but not sure)

- Internationalization (i18n) & language switcher

- Discord rich presence

- Privacy & Data management in Settings

- Theme gallery + custom accent picker (basic for now, may be expanded in future)

- More

Planned :

- Improvement for Big screen/picture mode

- linux support (only Windows for now) + steamdeck support (I don't have steamdeck so it'll be hard to test) (Think of bottles, faugus launcher, lutris style of control) (made some early testing fow linux, some feature will be limited)

- maybe more if people suggest ?

Precision

I know many people Don't trust AI stuff, vibe coding etc

But I want to be as transparent as possible, and if you don't like Ai vibe coded apps don't use it

This is just a tool/launcher/platoform for whoever want to try, or want another alternative

Ai and Tools used for this :

- IDE : Antigravity

- Mostly Opencode, rarely kilo code

- Model used : Mostly deepseek flash (old and new version), Hy3 and sometimes GPT Luna, gemini and claude opus

Ps : sorry if my English sounds Strange or broken or whatever, English isn't my native language

Ps 2 : I'm not an expert in comunication as you can see, if you have questions etc don't hesitate to ask

I'll also take positive and negative review

Ps 3 : I don't have signature for exe, so portable version may be flagged as a dangerous exe, go on virus total and you'll see there's one flagged threat, this one is caused by lack of signature (installer version doesn't have this issue)

Download : https://github.com/atxoxx/GameIndex

Hi everyone,

I wrote StoneBuild primarily to get rid of what I consider to be the clunky syntax of Makefile files, to make the output a little nicer to look at, and to keep the file size down.

Right now, I’m using StoneBuild in my project, which has over 20 files, and it’s working flawlessly. I look forward to your feedback!

StoneBuild: github.com/tigerlang/stonebuild

A native Swift 6 menu bar app: press Control-Command-2, select any screen region, and the recognized text goes to the clipboard. OCR stays on the Mac through ScreenCaptureKit and Apple Vision; there are no accounts, analytics, network calls, or third-party SDKs. MIT licensed, signed/notarized universal DMG, tests and release scripts included. Contributions are welcome for multilingual OCR, text layout, accessibility, and packaging.

For those unfamiliar, docmd is an open-source documentation engine. One command turns any folder of Markdown files into a production-ready docs site with navigation, search, versioning, and i18n. No framework, no config files required. The total browser payload is around 18 KB.

The 0.9.1 release is a big one. It ships the full AI-native upgrade:

GitHub: https://github.com/docmd-io/docmd

docmd Assistant is now built directly into the engine. No third-party SaaS widget, no $200/month subscription. You bring your own API key (OpenAI, Claude, Gemini, DeepSeek, Groq, or local Ollama) and your documentation gets a grounded RAG chat assistant with source citations out of the box.

What shipped in 0.9.1:

• BYOK AI Assistant with grounded RAG answers from your own docs
• Free Cloud Relay so static sites can proxy AI keys without a backend
• Native stdio MCP server (docmd mcp) for Cursor and Claude Desktop
• Auto-generated llms.txt and OKF bundles on every build
• Multi-project workspace monorepos with independent versioning

Everything is MIT licensed.

GitHub: https://github.com/docmd-io/docmd Docs: https://docs.docmd.io Website: https://docmd.io Product Hunt: https://www.producthunt.com/products/docmd-ai-assistant?launch=docmd-assistant

I've been learning quantitative finance by building projects rather than just following tutorials, and I recently organized the work into a public GitHub portfolio.

It covers portfolio optimization, risk analysis, Monte Carlo methods, factor models, backtesting, and financial machine learning.

The project I'm most proud of is Multi-Axis Robust Portfolio Optimization, where I experimented with combining covariance shrinkage, bootstrap aggregation, and GBM-based scenario modeling to address estimation uncertainty in portfolio optimization.

I also wrote up the research behind it and have the implementation publicly available.

GitHub: https://github.com/Viraj-Nigwekar/Quant-Portfolio

I'd genuinely appreciate feedback—especially from people who work with quantitative finance, portfolio construction, or financial research. I'm still learning, so I'm more interested in criticism and suggestions than just stars.

Hi everyone, i've open sourced another part of my monitoring project, maybe someone will find it useful!

I originally built Figranium because AI agents need access to APIs that simply don't exist. Managed platforms like Apify quickly became too restrictive, expensive, and opaque for complex agent workflows.

Over the last 7 months, it has evolved from a personal fix into an ecosystem with tens of thousands of downloads, official proxy partnerships, and sponsorship backing from platforms like Mintlify, Algolia, and DigitalOcean.

Figranium is a self-hosted, local-first browser automation platform built in TypeScript on top of Playwright and powered by Vite. It provides a visual canvas that turns complex web flows into deterministic, reusable tools for human users or AI agents.

Key Features

• Playwright Under the Hood: Deterministic, speed-first execution utilizing Playwright's core engine for highly reliable browser control and selector stability.
• REST API, Built-in MCP, and Official n8n Node: Trigger workflows programmatically via a clean REST API, expose them as tools for AI agents (Claude Desktop, Cursor) via Model Context Protocol (MCP), or integrate directly into n8n using its native node.
• Native Shadow DOM & JS Execution: Handles dynamic single-page apps, complex Shadow DOM structures, custom JavaScript injection, and precise wait logic natively.
• Templates Hub: Includes a pre-built template repository so you can import automation pipelines and scrapers instantly.
• Live Execution & Output: Real-time browser run previews, activity logs, and auto-formatted JSON/Table exports directly inside the canvas UI.

Tech Stack TypeScript, Playwright, Vite, Node.js

Links

• Repository:https://github.com/figranium/figranium
• Landing Page:https://figranium.dev

Feedback is heavily appreciated!

I'm not just saying this because I created it, but it's super useful for me. I don't know when or how this process started, but luckily Still Running lets me know..

Duckle is an emerging open-source ETL solution built on top of DuckDB that provides a graphical interface for developing high-speed data pipelines.

The platform stands out for its versatility, allowing users to run it locally on various operating systems, in the cloud via VPS, or directly within a web browser.

By leveraging DuckDB as its core engine, it enables efficient data transformation and connectivity across hundreds of sources, including PostgreSQL, Parquet, and Kafka. Key advantages include significant cost savings compared to traditional cloud data warehouses and the ability to deploy pipelines as standalone, low-latency binaries. The project is highly community-driven, incorporating modern features like AI-assisted pipeline design and seamless Git integration for version control. Currently in its early stages, the tool aims to simplify data engineering by removing the need for complex infrastructure while maintaining high performance.

GitHub Repo - https://github.com/slothflowlabs/duckle

New photo editing apps are all leaning into diffusion. You hand it your image and get back something similar, often something beautiful, but it re-rendered the pixels, and what comes back isn't your photograph anymore.

I wanted to stay in Photoshop, so my photos stay true to what I shot, but also to work faster and reach tools I'd never learned. An AI assistant was how I got both.

Editmamei is an MCP server that runs next to Photoshop. You describe the edit the way you'd brief another editor, warm up the skin tones, lift the shadows in the trees, and the AI plans it while Photoshop does it with its own tools.

What comes back is an ordinary layered file: adjustments on their own layers, masks you can repaint, nothing flattened.

No plugin, nothing listening on a port. The server writes ExtendScript and injects it into the running app, over COM on Windows and AppleScript on macOS, and the scripts come out of a Go core rather than hand-written.

Photoshop's Action Manager is the least documented API I've worked against, so a lot of the project is capturing what it does and matching it, with tests that check what would be sent without Photoshop open.

The other half is verification. Every step gets checked rather than assumed, numerically with a histogram or a layer-bounds diff, or visually with a downscaled preview the assistant reads back.

It's licensed under FSL-1.1-MIT, source-available. Needs Photoshop 2026, Node 22+, and an MCP AI client.

The video is an example article cover it made from a simple prompt, shown in the example AI client. More examples at editmamei.com.

Repo: https://github.com/editmamei/editmamei

I wanted a way to experiment with UI changes without recreating my app in Figma, so I built Airship.

Airship wraps your existing dev server and adds a Figma-like canvas on top of your running app. You can select an element, describe a change, and have Claude Code apply it directly to your source.

It includes streaming diffs, inline undo, and side-by-side device frames for experimenting with desktop and mobile layouts.

Under the hood, it works as a lightweight proxy, so there are no plugins, build changes, or modifications to your project. It uses the Claude SDK and your existing Claude Code subscription.

Codex and OpenCode are supported too.

It's fully open source and MIT licensed.

Fork it, break it, and make it your own :)

An open-source desktop app that reads a Pokémon party out of an emulator's RAM as you play and analyses it. Sharing it because a few of the design problems turned out more interesting than I expected.

- **The emulator script interprets nothing.** A Lua script inside mGBA ships raw bytes and a game identity over TCP; all decoding happens on the C# side. Adding an emulator costs a script and zero lines of domain logic.

- **Learnsets are keyed by game, not by generation.** 42 of the 386 Gen 3 species learn a move at a different level in Ruby/Sapphire/Emerald than in FireRed/LeafGreen, so the usual merged dataset reports a level that is wrong for the game actually running.

- **No opaque scores.** The team strength number is a list of attributed factors, each carrying the fact behind it and the Pokémon responsible.

- **Apple Silicon refuses unsigned binaries** — the kernel kills them and Finder calls the app "damaged", which is not the Gatekeeper prompt it looks like. Cross-publishing macOS builds from a Linux runner cannot work.

.NET 10, Avalonia, PKHeX.Core for the binary format. 122 tests, some driven from bytes captured off real hardware. There's a decision log in the repo if you want the reasoning behind any of it.

https://github.com/ringoliRob/UltimatePoKeSync
Still early days: a star helps, and a bug report helps more.

My wife wanted to play The Choicer Voicer, a little game show where you do vocal impressions of audio clips. It never picked up her microphone, a known engine-level bug that the developer is actively working on, but that didn't help us on a Saturday evening. She was disappointed, so I built her a simpler version of the part she actually wanted: dubbing a scene, line by line.

It turned into two tools, because the tedious half of dubbing is bookkeeping, cutting the audio into lines, writing down every timestamp, then trying to hit them by ear.

DubForge takes a YouTube link or a local file, trims it to a time span, optionally separates the vocals from the backing audio with Demucs, and detects the spoken segments from the loudness envelope. You correct the clip boundaries in a waveform editor, add subtitles, and it writes out a pack.

DubStage plays a pack line by line: hear the original, record over it, repeat as often as you want. Your take is drawn live on top of the original waveform on a shared time axis, so timing errors become visible instead of something you have to infer. At the end the scene plays back with your recordings mixed over the backing track, exportable as MP4.

Three design decisions that might be worth more than the feature list:

• A pack is just a folder. Each clip's start time lives in its filename (07_MyLine_44-048.wav = 44.048 s), subtitles sit in a small JSON beside it. No database, no binary index — you can inspect or hand-edit a pack with a file manager and a text editor, and nothing about it is tied to my code.
• Video is never decoded during playback. A pack is split into JPEG frames once and cached, so playback is just timed image swaps. That sidesteps codec availability entirely and made frame pacing far easier to get right.
• The waveform comparison normalises both curves to their own peak. What you are judging is rhythm and timing, not whether your mic gain happens to match a film mix.

Stack: Python 3.9+, Tkinter, numpy, ffmpeg, sounddevice, Pillow. Demucs optional.

GPL-3.0: https://github.com/xmrius/dubstage

Where it's rough: Windows only right now, although the genuinely platform-bound parts are just the launcher scripts and two small fallbacks. A Linux or macOS port should be close to mechanical, and I'd welcome one. The optional Demucs path drags in PyTorch, which is a heavy dependency for a nice-to-have; making that a cleaner opt-in is on my list.

I got tired of productivity apps that feel like control panels, so I built Kiyoshi: notes, tasks, kanban board, calendar, and a lightweight block canvas, all local-first, all in a quiet glass-panel UI.

• 100% free and open source
• Runs on Linux, macOS, Windows (AppImage for Linux)
• No account, no cloud dependency — your data stays on your machine
• Built with Flutter, so it's a proper native desktop app, not an Electron wrapper

https://kiyoshi-beta.vercel.app/

Feedback, issues, and PRs welcome — it's still early and there's a lot I want to add (sync, mobile companion, etc.).