Vice is a Linux game clipper that focuses on easy sharing and editing. Under the hood, it uses GPU-Screen-Recorder as the capture engine, so it has nearly no performance impact whatsoever, and it has features such as:

- Instant replay with customisable hotkeys, and long session recording

- Free share links that embed in Discord (no more hitting upload limits!)
- A full timeline editor with built in transition and text effects
- Automatically sorting clips by the game you were clipping
- Discord Rich Presence support
- Customisable, colour-coded highlights within clips

- You can seperate audio sources like Discord calls, the game audio, and music, adjust their individual volume in clips

- And more, plus new features are always being added.

It's free, open source, and will stay that way. Any feedback is greatly appreciated, because community testing is what makes open source projects like these better.

It's on the AUR, and you can install with:

yay -S vice-clipper

Or if you're on a different distro, you can run the install script with:

git clone https://github.com/eklonofficial/Vice && cd Vice && ./install.sh

Repo is below:

https://github.com/eklonofficial/Vice

Timelines Studio is a free, open-source desktop app for building interactive timelines, aimed at worldbuilding and history. Everything is local-first: your timelines are plain .timeline (JSON) and .md files on your disk. (Website)

I started this project because I wanted to visualize history notes I was taking in Obsidian as a timeline. It's still a work in progress, currently at 12 releases and 36 stars on GitHub, but I've been getting lots of great feedback and suggestions from users who've found the app useful, and there's a lot more coming.

Features include:

• Events, spans, and eras, with thumbnails, icons, and spans that can branch from or merge into each other
• Tags and groups for filtering the canvas down to what you're working on
• Notes and sources: attach Markdown notes to any element, pull in MediaWiki content directly, and point the notes folder at an existing vault like Obsidian
• Map view: give an event or span coordinates and watch the timeline unfold across geography
• Spreadsheet view for bulk editing dates and names in a sortable table
• A marketplace of 100+ community themes, with a different theme per timeline if you want
• Web viewer: open any .timeline file in the browser, and if it lives in a GitHub repo you can paste the link to get a shareable URL that works without installing anything
• More on the way, including git sync. Roadmap is public in the issues

It's free, open source under GPL-3.0, and will stay that way. Feedback and bug reports are very welcome, that's most of what has shaped it so far.

Windows and macOS installers are on the releases page:

https://github.com/sreegjl/timelines

I've been watching Nova Designs on YouTube for a while and loved how clean his code presentations look. Turns out he uses CodeSlides which is great, but it's subscription-based.

So I built OpenSlides — a free, open-source, fully offline desktop app for making animated code presentations. Think CodeSlides, but it runs natively on your machine, your data never leaves your disk, and you own everything.

https://github.com/codewiththiha/OpenSlides.git

A thank you for open source builders. You put in the work, we want to send something back.

Drop your open source repo below. My team picks one they find interesting. No star requirement, no follow, no catch. Winner gets a Fleet device shipped for free.

What's Fleet? I was running Claude Code on my laptop, Codex on my desktop, more agents on servers. No way to manage them all. So I built a device that sits on your desk and connects to every agent across every machine. You talk to it, agents send you status updates, you don't need 10 terminal tabs.

Been using the prototype for a month. Cant live without it.

Drop your repo. Thanks for what you build.

Edit: I didn't think that I can gather this many great people. I might not be able to reply to you all but be assure that my team will check all of the repos here. Will try to make this a weekly event, so for this week, the deadline is Sunday. Big thanks to all of you.

Most Kubernetes TUIs show you tables. LFK shows the hierarchy.

I've been building LFK for a few months now, it's a keyboard-first Kubernetes navigator inspired by yazi's three-column layout:

• parent, current, and preview, always visible. You navigate clusters the way you actually think about them: Clusters -> Deployments -> Pods -> Containers.

A few things I haven't seen anywhere else:

• Union view - merge resources from multiple clusters into one table
• Object and API Explorer - walk any live object or its schema as a drill-in tree
• Log Top - turn raw logs into live traffic stats: REQ/s, ERR%, p95/p99 latency
• Crash Investigator - restart history, events, previous logs, and describe in one view
• Orphan detection - find unused Secrets, ConfigMaps, PVCs and more across 11 kinds
• Security dashboard - aggregates Trivy, Kyverno, Falco, Kubescape, plus built-in scanners
• Read-only mode - lock a session against deletes, edits, and restarts
• Can-I / Who-Can RBAC browsers - instant visibility for RBAC permissions both ways
• Network policy visualizer - see a policy's rules, or every policy affecting a Pod (Cilium included)
• Traffic capture - live packet decode and pcap export, straight from a Pod's action menu
• Local clusters - spin up kind, k3d, or minikube without leaving the app
• Named sessions - save whole multi-tab workspaces and switch between them
• Integrations with a lot of other well-known tools - ArgoCD, Helm, Argo Workflows, KEDA, External Secrets, etc...
• 460+ themes with live preview and auto dark/light switching
• Vim-driven - counts, visual selections, text objects, in every viewer
• And a lot more...

If you spend your day in kubectl or k9s, give it a try. I'd love to hear what's missing.

Free and open source (Apache 2.0), installs with brew, scoop, apt, dnf, or go install.

After months of work, I just released v5.0 of my terminal-based hacking game and it's now open source!

🖥️ What is it?

A Python game where you play as a hacker. You infiltrate servers, evade firewalls (memory mini-game), and crack passwords using clues. It's 100% terminal-based with colorful UI.

🔥 What's new in v5.0?

• 20 servers to hack (from easy to legendary)
• 25+ achievements with rewards
• 4 visual themes (Matrix, Cyberpunk, Classic, Dark)
• Save/Load system (JSON)
• Daily missions with double rewards
• Ranking system with fake competitors
• 8+ tools to buy in the shop
• 4 mini-games: Firewall, Cryptography, SQL Injection, Logic Puzzles

🎯 Try it now!

git clone https://github.com/DlopedDtorred/hacker-simulator.git
cd hacker-simulator
pip install colorama
python cyberdex.py

🔗 GitHub: https://github.com/DlopedDtorred/hacker-simulator

🤝 Looking for contributors!

Areas where you can help:

• Add more servers with creative password puzzles
• Create new mini-games
• Improve the UI
• Add more achievements
• Translate to other languages

Check the issues tab for "good first issue" labels!

📊 Current stats:

• ⭐ 25+ stars in first week
• 🍴 8 forks
• 👥 3 contributors

Would love to get your feedback! What other features would you like to see?

Questions for the community:

• What other mini-games would be fun?
• Any server ideas with creative password puzzles?

Thanks for checking it out! 🙌

#Python #OpenSource #GameDev #Hacking #SideProject

Just built a CLI tool that makes conventional commits easy.

bash

git clone https://github.com/dlopeddtorred/commit-helper.git
cd commit-helper
npm install
npm run build
./dist/cli.js new

Features:

• Interactive commit builder
• Validates commit messages
• Generates changelogs
• Git hooks support

No more memorizing commit formats.

Repo: https://github.com/dlopeddtorred/commit-helper.git

Routeveil is an open-source React + TypeScript transition system for React Router.

It provides:

- 20 built-in page and overlay transitions

- transition-specific TypeScript options

- declarative RouteveilLink navigation

- programmatic navigation

- previews without route changes

- cursor-aware radial effects

- reduced-motion support

- support for custom transitions

The transition engine handles the route exit, navigation, incoming render, entry animation, and cleanup without requiring animation code inside page components.

Repo:

https://github.com/milkevich/routeveil

Interactive demo:

https://routeveil.dev

Test out the transitions:
https://routeveil.dev/lab

built this over a weekend and figured some of you might want it on your profile readme. it renders your contribution graph as a snake that actually plays the game: it pathfinds to your commits, avoids its own body, and grows as it eats. one python file and you add it with a single github action.

https://github.com/dahan8473/snake-and-commits

happy to take feedback or feature requests.

I've been spending most of my day bouncing between a dozen terminal tabs and SSH sessions, so I built cTerm — a full-stack web app that gives you an IDE-style workspace for real shell sessions, all running in the browser.

It's a Node.js/React app under the hood: xterm.js on the frontend and node-pty on the backend, talking over WebSockets, with token-based auth so you're not leaving a shell open to the internet.

What it does:

• Split any terminal pane horizontally or vertically to build a grid of live sessions
• Drag and drop a terminal's header onto another pane to instantly swap sessions
• Save multiple named workspaces, each with its own independent pane layout
• Reconnect to running shells automatically — refresh the page and your layout, splits, and scrollback are all still there
• Connect a workspace to a remote host by pointing it at a standalone PTY server (handy if you're managing boxes/VMs in different places)
• Themes (Dracula, Nord, Cyberpunk, One Dark, Light), adjustable font size, and cursor style, because if I'm staring at a terminal all day it should at least look good

It's fully Dockerized (docker compose up -d --build and you're running), or you can run it locally with npm run dev.

Full setup instructions (local dev, Docker, and multi-host deployment) are in the repo: 👉 https://github.com/isdartho/cterm-workspace

It's MIT licensed. Would love feedback on the UI/UX or ideas for what to build next — a few things I'm already chewing on are command history search across panes and shareable read-only session links.

At Bitwize, we've been building Logue, a native macOS app for AI meeting notes and writing, and we just open-sourced it (MIT). We're sharing it here because the whole point is that it runs 100% on-device — we wanted something that could transcribe and summarize meetings without shipping audio or notes to anyone's cloud.

By default, nothing leaves your Mac. The only network calls are the initial on-device model download, app update checks, and opt-in features you explicitly turn on (web search or plugging in an external AI provider if you want one). No accounts, no telemetry, no backend.

What it does:

• Real-time transcription of mic and system audio (Apple's on-deviceSpeechTranscriber)
• Speaker diarization — who said what — via FluidAudio (streaming Sortformer)
• "Smart Minutes": local LLM summaries, action items, highlights
• Writing assistant: 60+ modes (rewrite, grammar, clarity, tone), a document editor with AI chat, vocabulary suggestions
• On-device PII detection and a fact-check/verify panel
• Templates, Spaces, and "Ask Logue" chat over your own notes

Stack: Swift + SwiftUI/AppKit, MLX (mlx-swift-lm) for LLM inference, Apple's Speech framework, FluidAudio for diarization, Sparkle for updates. Data is AES-256-GCM encrypted at rest.

Honest caveats: it targets macOS 26 (Tahoe) and Apple Silicon only (MLX + the new Speech APIs), so it won't run on Intel or older macOS. It's early — expect rough edges — and we'd genuinely love feedback, issues, and PRs.

Repo: https://github.com/bitwize-ai/Logue

Happy to answer anything about the on-device pipeline, MLX inference, or diarization in the comments — we're the team that built it. 

I wanted a simple way to share passwords, API keys, and snippets without trusting a server with the plaintext, so I built binthere.

It's a zero-knowledge, end-to-end encrypted pastebin where everything is encrypted locally in your browser using AES-256-GCM before it's uploaded. The server only ever stores ciphertext, while the decryption key stays in the URL fragment and never leaves your device.

It's built as a single Cloudflare Worker, supports one-time ("burn after read") notes with 24-hour expiry, includes an official CLI, and is fully open source.

I'd love to hear any feedback on the security model, architecture, or overall UX.

GitHub: https://github.com/nxfu/binthere

Demo: https://binthere.gaury.dev

Docs rot the moment code changes, and nobody updates them on purpose - RepoDocs regenerates them, citing file:line for every claim.

It's a CLI, not a plugin: it shells out to whatever coding agent session you already have open (Claude Code by default, or OMP/Codex), scans the repo deterministically first, then has the agent write each page from what the scan found. Rebuilds hash sources and only regenerate what changed. It also diagrams how the modules fit, and can publish straight to a GitHub Wiki. Publishing is guarded (dry-run first, refuses main/master/trunk, scans for secrets).

Zero runtime dependencies - Python 3.10+, stdlib only. v0.2.0. Runs locally; your code never leaves your machine.

uvx --from repodocs repodocs-all .

> github.com/aryrabelo/repodocs — if you try it, tell me what broke.

Hi everyone,

I built Cortex, an open-source runtime analysis and debugging toolkit for Windows games and native applications.

The goal is to combine several workflows that usually require separate tools into one interface: memory scanning, debugging, patching, screenshots, input automation, disassembly, and persistent project data.

Cortex uses two components:

• an external host for memory scanning and analysis;
• an injectable agent for live debugging, renderer hooks, screenshots, native calls, and background input.

Everything is exposed through authenticated local REST APIs, with OpenAPI discovery and a native MCP endpoint for scripts, developer tools, and AI agents.

Some of the current features include:

• x86 and x64 support;
• typed memory reads and writes;
• exact, comparative, AOB, and string scans;
• breakpoints, traces, disassembly, CFGs, and xrefs;
• tracked patches, freezes, trampolines, snapshots, and rewind;
• background screenshots and keyboard/mouse input;
• Direct3D 8–12 and OpenGL support;
• persistent addresses, pointer paths, structures, and notes.

The project is intended for authorized debugging, offline research, accessibility tooling, and single-player modding. It is not intended for bypassing anti-cheat systems or interfering with online services.

I’d really appreciate feedback on the architecture, API design, documentation, and potential use cases.

GitHub: https://github.com/PdB333/cortex

Hey everyone,

I use Mermaid for diagramming, but I was tired of tools that require a login, track usage, or save data to a third-party cloud. I just wanted a simple tool where my diagrams stay completely private (and I couldn't find one).

So I built Mermify. It’s fully client-side, runs entirely in your browser, and doesn’t track a thing. I just updated it to v0.3 it now supports Flow Charts & Sequence Diagram.

What it actually does:

• Real-time Sync: Type raw Mermaid syntax in Monaco or visually drag nodes/edges on the canvas. It syncs instantly both ways.
• Drag-to-Create & Inline Editing: Drag from a node's socket into empty space to spawn connected nodes, and edit labels directly on the canvas.
• 100% Private Links: Uses pako to compress the entire diagram state into the URL hash. No database, no backend.
• Run it Anywhere: Zero backend means you can easily self-host it, or just install it as a standalone desktop PWA.

The Rough Edges & Tech Stack:

I'm mostly used to Python and Docker environments, so TypeScript isn't my native tongue. I used an LLM to handle the TS syntax heavy-lifting while I focused entirely on the UX logic, product flow, and writing robust E2E/unit tests.

Note: It's strictly for desktop right now (screens width ≥ 1024px) due to the side-by-side layout.

I’m really proud of how it turned out, but since I'm stepping out of my comfort zone with TS/React, feel free to roast the app or the implementation (constructively!). Let me know what features you're missing or what I can improve.

🚀 Live App:https://tra-sco.github.io/mermify/

📦 GitHub Repo:https://github.com/tra-sco/mermify

A place to take a break, chat with people around the globe, listen to some music, play a game, water your bonsai. All in your terminal.

ssh late.sh

That's it :) No passwords, no OAuth, no accounts. Your SSH key is your identity.

Last time I posted here, our "big multiplayer game" was blackjack. Well... we kinda went wild since then :D

The roguelikes

• Dungeon Crawl Stone Soup: the most played roguelike of the modern era, real console crawl running over SSH, your save persists. Soon connected to https://dcss-stats.com .
• NetHack: the one hanging in a museum (literally, MoMA has it). The real upstream game running over SSH: your save persists, the dead stay down there, and your bones haunt other late.sh players.
• and a third classic is landing soon... arguably the most beautiful ASCII ever put on a terminal ;)

The BBS door games

• Legend of the Green Dragon: the classic LORD, rebuilt native in Rust for the terminal. Hunt the forest, beat your master, slay the dragon. We've got big plans for this one :)
• Usurper: the actual LORD-era door from the 90s, resurrected on a PTY, one shared persistent world.
• Lateania: our own persistent multiplayer text-world. Pick a class, fight turn-based combat, drop bosses. Your character lives between sessions.
• dopewars: buy low, sell high, dodge the cops. One sitting, shared high-score board.
• Rebels in the Sky: ricott1's brilliant space-pirate basketball roguelike, playable door-game style.

The Lobby

Ctrl+Q anywhere and you get every multiplayer game in one list:

• correspondence games, chess, battleship, connect four, reversi, checkers, backgammon. Post a challenge, walk away, play one move whenever you're around. 24h per move or you forfeit, winner gets chips. Every match gets its own private chat + voice room for proper trash talk :D
• five always-on house tables you just sit down at, poker, blackjack, tron, super snake, asterion
• spectate any live match
• and the roster keeps growing, card games are next, gin rummy is looking good ;)

Turns out correspondence chess over SSH is a hit. Who knew.

The Arcade grew too

• new games, Le Word (one global daily word for everyone, so the chat gets competitive), Traffic (multi-track racing), and a Rubik's Cube (real cube, same daily scramble for everyone)
• daily puzzles across the board (sudoku, nonograms, minesweeper, solitaire, le word, rubik), daily quests and streaks that pay chips, monthly champions get permanent profile badges
• and a shit ton of QoL, like one backtick key that cycles you through your unfinished dailies, boards where it's your move, and back to chat

MUSIC

• the booth, a community YouTube jukebox. Queue tracks, vote, skip, browse the history of everything that ever played. Someone's always DJ-ing.
• the radio, live synthwave from Nightride FM, with their blessing and live artist/title attribution. Five stations: Chillsynth, Nightride, Datawave, Spacesynth, Ambient.
• the library, 600+ curated CC0/CC-BY tracks (lofi, ambient, classical), all controlled from inside the TUI

Chat leveled up too, polls, image previews, an embedded IRC server (use late.sh from any IRC client, irc.late.sh port 6697 TLS)... and VOICE chat. In your terminal. No browser :D

Everything from before is still here, the live artboard (https://late.sh/gallery), news feed with ASCII thumbnails, profiles + showcase (https://late.sh/profiles), the classics (2048, tetris, snake) with leaderboards and badges.

Oh, and did I mention the whole thing now has a fully ASCII clubhouse? A walkable tavern where you see everyone who's online, sit at the bar, wave, dance, and buy a drink from the AI bartender with your chips. It's the front door of late.sh now :)

Still a team effort, still a great vibe. Hop in, take a break ;)

License: FSL-1.1-MIT

Code: https://github.com/mpiorowski/late-sh

Landing: https://late.sh

Demo: https://late.sh/play

Hey everyone,

I built DevTime, a CLI tool that scans your repo and creates a local “memory” of how your project actually works.

It helps you:

• Understand the big picture (concepts + relationships)
• Get answers about your codebase
• See what’s risky in a change before you commit
• Keep decisions & context in one place
• Works offline. No cloud, no telemetry, open source.

I made it because I got tired of re-explaining the same parts of my projects to new teammates and AI tools.
Would love feedback from you all 🙏

Repo: https://github.com/Shakargy/devtime

I built The Email Game: you design a Python AI agent that competes against other people's agents over simulated emails. Each agent can cryptographically sign messages only for the agents it's authorized to, and has to cooperate with the same rivals trying to manipulate it into signing something it shouldn't. A base class handles the protocol, RSA signing, and email plumbing, so you just write the decision logic. It's live and you can compete virtually from anywhere; the next competition is Aug 1: theemailgame.com. Built it during my AI research fellowship at WithAI (YC P26), feedback is welcome!

HakPoint is a modular enterprise management platform that helps companies centralize and manage their daily operations from one responsive interface.

Built with PHP 8.2+, MySQL, PDO, HTML, CSS, and JavaScript, it is suitable for SMEs, distributors, retailers, service companies, and organizations looking for an adaptable business-management solution.

Main features

• 📊 Dashboard with KPIs, charts, summaries, and recent activity
• 🤝 CRM management for prospects, customers, and suppliers
• 📦 Product and service catalog with pricing, margins, notes, and files
• 🏬 Warehouse and inventory management
• 🔄 Stock transfers, adjustments, movements, lots, serial numbers, and physical inventories
• 📝 Complete sales workflow: quotations, orders, invoices, credit notes, and payments
• 🛒 Supplier purchases, purchase orders, supplier invoices, and payments
• 🚚 Shipment and reception management
• 🏦 Bank accounts, payment methods, reconciliation, and cash-flow tracking
• 📚 Basic accounting with accounts, journals, periods, entries, balance, and general ledger
• 📄 PDF generation for business documents
• ✉️ Email preparation and document sharing
• ✍️ Electronic signature workflow
• ✅ Approval and validation workflows
• 📈 Business reports, analytics, status monitoring, and Excel/CSV exports
• 📂 Document management and secure uploads
• 👥 User accounts, hierarchy, roles, and granular permissions
• 🔐 Two-factor authentication, CSRF protection, login controls, and audit logs
• 💾 Database backup and restoration
• 🔌 REST API protected by API keys, Bearer authentication, and configurable CORS
• 🤖 HakPoint AI assistant with French, English, and Arabic support
• 🧩 Optional modules for projects, agenda, POS, manufacturing/BOM, currencies, and custom fields
• 📱 Responsive interface for computers, tablets, and mobile devices

How HakPoint helps companies

Technology stack

• Backend: PHP 8.2+
• Database: MySQL with PDO
• Frontend: HTML5, CSS3, JavaScript
• Dependency management: Composer
• Integration: REST/JSON API
• Hosting: Standard PHP/MySQL hosting, Apache/cPanel, or Caddy-based environments
• Architecture: Modular, configurable, and designed for future extension

Free public version

HakPoint is available publicly and is intended to remain free and open source.

I am not requesting payment for the public version. If you find the project useful, the best way to support its development is simply to give the repository a ⭐ on GitHub.

Every star improves the project’s visibility and encourages me to continue adding features, improving security, and making HakPoint more professional.

👉 GitHub repository: github.com/hakkachhamza/HakPoint

Private and customized version

Companies that need a more specialized solution can request a private and professionally customized version, including:

• Custom branding and interface
• Company-specific modules and workflows
• Integration with existing websites, APIs, or databases
• Private GitHub repository
• Deployment and configuration
• Security hardening
• Data migration
• Maintenance, training, and technical support

Pricing can be adapted fairly according to the company’s requirements, project scope, and expected support.

Contact Hamza Hakkache:

• [LinkedIn]()
• Email: [[email protected]]()

I kept running into the same problem: I'd solve an issue or make a technical decision, and a few weeks later I had to search through old AI conversations, Git history, and manual notes to recover the context behind it.

So I built Kote.

It indexes development context from AI conversations and Git, then adds a CodeLens above your code in VS Code. When you open a file, you can immediately see the discussions and decisions that led to that implementation instead of digging through old chats or commit history.

The context is also searchable through a web UI, CLI, and MCP server. It's self-hostable and works with your own LLM provider.

See More: https://github.com/pedroaugusto04/Kote

I'm curious if anyone else has this problem, or if you've found a better way to preserve the reasoning behind technical decisions.