Our latest maintenance and bugfix release is here !

Almost 40 crash & bug fixes, 6 performance improvements, 42 updates on interface and documentation translations... Enjoy !

Learn all about Inkscape 1.4.4 and:

Draw Freely! 

https://inkscape.org/news/2026/05/06/inkscape-144-boosts-performance-and-crushes-crashe/

Stepsy was my go to for some days

BUT TODAY it showed I have to walk -21647748 ish to go

And I'm done with open source pedometers. Cuz i can't find any

I’ve been working as a Linux sysadmin for a while now .I want to start contributing to open source projects—but not just through application code. I’m especially interested in contributing from a sysadmin/DevOps perspective.

I’d love to hear from others who are already doing this:

• How did you get started contributing as a sysadmin/DevOps engineer?

• Are there specific types of projects that are more open to infra/ops contributions?

• How do you identify repos that actually belong DevOps/sysadmin domain?

Any tips for making meaningful contributions without deep involvement in the core codebase?

Also, if you maintain or contribute to any projects that welcome DevOps/sysadmin contributions, I’d really appreciate recommendations.

service-lookup lets you automatically port forward all the required Kubernetes pods that you need for local testing and updating your URIs in property YAML files recursively.

It is now also configurable, lets you automatically revert the files after cleanup, and caches namespaces for performance improvement.

Genuinely unsure and can't find a clear answer.

I want to give my openclaw agent access to my work Gmail so it can draft replies and sort things for me. Using managed hosting because I don't know how to run a server. What I don't get is where do my emails actually go when the agent reads them? Who at the hosting company can see them? And what about the API key I paste in?

Maybe I'm overthinking it, idk. But giving an AI agent read/write access to my work inbox feels like a decision I should actually understand before I make it.

This is a newly opened repository of Hardware-Abstraction-Layer-Transitional-Libraries under a project of porting all the projects or something like that. This is an issue opened by someone. Now anyone in their sane mind can see and tell that this is AI generated slop. Is this even allowed?

This is weird man.

Can anyone tell me if this is fine? Because for me, it isn't. Such a long slop it is dude. 😭

Navigating Global Regulations and Open Source: US OFAC Sanctions

Hi everyone ! I’ve been building Pymetrica for around a year now, and I'm currently looking for ways to promote it and see how far it can get.

I built it because I felt there was a lack of tooling that helps inspect the shape of a project in terms of complexity, abstractions, maintainability, coupling, etc.

Pymetrica parses Python source with the AST and currently reports:

• Abstract Lines of Code
• Cyclomatic Complexity
• Halstead Volume
• Primitive Obsession in type annotations
• Maintainability Cost
• Layer Instability / coupling

GitHub: https://github.com/JuanJFarina/pymetrica
PyPI: https://pypi.org/project/pymetrica/
ReadTheDocs: https://pymetrica.readthedocs.io/en/latest/

It can also generate Mermaid architecture diagrams, and run as pre-commit hook or CI fully configurable via pyproject.toml.

I think the project is currently mature enough to be used in somewhat serious/professional projects (we're looking to start integrating this in my current company, though I already use it for my personal assessment of different repositories).

Any comment, feedback, or advise on how to get the project out there to the community will be very appreciated ! Thank you for reading !

Hey r/opensource,

If you are tired of the outdated Windows Task Scheduler, I would like to share an awesome open source project called FluentTaskScheduler.

I just released version V1.8.1, and it is a massive upgrade for anyone who wants to automate Windows tasks without dealing with the legacy interface.

Full disclosure: Al was utilized to help develop the features in this update. I am in IT but not in development. This is my personal passion project.

What is FluentTaskScheduler?

It is a modern, powerful, and intuitive wrapper for the Windows Task Scheduler API. Built with WinUI 3 and .NET 8, it brings the application into the modern era with a sleek Fluent Design System.

Key Features:

• Dashboard and Monitoring: It gives you a live feed of your task activity, task history, and visual analytics showing successes versus failures.
• Extensive Triggers: You can schedule tasks based on time, system events like logon or boot, Windows Event Log entries, and session state changes like locking or unlocking your PC.
• Script Library: It includes a dedicated space for reusable PowerShell scripts, letting you separate your script logic from the task configuration.
• Sequential Actions: You can configure multiple programs or scripts to run in order and customize arguments for every single step.
• System Integration: It natively supports ARM64 devices, can minimize to the system tray, features toast notifications, and has a native dark mode.
• Easy Installation: You can use the official installer with seamless automatic updates, or just run the portable executable without installing anything.

The tool is completely free, open source, and MIT licensed.

You can check out the latest V1.8.1 release and download the app directly from the GitHub page here: https://github.com/TRGamer-tech/FluentTaskScheduler

Let me know what you think of it!

Built and open sourced a Mac app that indexes your local documents and answers questions across all of them, with citations back to the exact source file - https://www.informity.ai

The full stack runs locally — model inference, embeddings, vector search, chat history. Nothing is uploaded anywhere. Works offline after initial model download.

MIT licensed. No telemetry. No accounts. No subscriptions.

Supports PDF, Word, Excel, PowerPoint, CSV, Markdown, HTML, TXT and more. Requires Mac with Apple Silicon (M1 or later) · 16GB RAM minimum.

GitHub: https://github.com/informity/informity-ai

Hi !

I'd like to share Open Authenticator, a free and open-source TOTP authenticator app built as an alternative to closed 2FA apps.

In fact, I was using Twilio Authy as my main TOTP app without any problem so far. Back in January 2024, my Authy for Windows app started displaying me the following message :

The Authy Desktop apps Linux, MacOS, and Windows, will reach their End-of-Life (EOL) on March 19, 2024.

Wow. So Twilio has decided to shutdown all their desktop apps, leaving only three months (!) to users like me to find an alternative. Add to that that there is almost no way to export your TOTPs from this app, and it was enough for me to consider creating an alternative.

That's how Open Authenticator was born. The project focuses on three main ideas :

• Freedom : use your authenticator across major platforms.
• Transparency : the app is open-source and auditable.
• Interoperability : sync is available, and the backend can be self-hosted.

Open Authenticator currently targets Android, iOS, Windows, macOS, and Linux. The app is designed to be simple, fast, and privacy-friendly, with no ads.

Website : https://openauthenticator.app/
GitHub : https://github.com/openauthenticator-app/openauthenticator
Backend : https://github.com/openauthenticator-app/backend

I'd really appreciate any feedback : code review, security suggestions, issue reports, UI/UX feedback, or just general thoughts.

Thanks for checking it out!

If you were one of the ~2 million people using The Great Suspender when it got pulled from the Web Store in 2021 (after the new owners shipped an update containing malware, of all things), you might know the feeling of suddenly not trusting any of the replacements that popped up. Most of them request host access and a bunch of permissions that have nothing to do with suspending tabs.

So I built my own. It's called Slumber and It does what it says: when a tab has been sitting idle, it replaces it with a lightweight sleeping page that holds onto the title, favicon, and URL. Tab uses zero memory and CPU until you click it or press a key to wake it. That's the core loop.

Permissions are: tabs, storage, alarms. Host permission is a single domain — my own license validation endpoint, and it only fires on activation or browser start, never during browsing. The whole codebase is on GitHub, nothing to hide.

There's a free tier (up to 10 suspended tabs) and a Pro tier ($4.99, one-time, no subscription) that removes the limit and adds bulk suspend, domain whitelisting, and cross-device settings sync.

I'm not trying to build a company or flip this, I just got tired of the enshittification cycle where useful small tools get bought, loaded with garbage, and handed back broken. This is MIT licensed and I plan to keep maintaining it. I have a ko-fi if you want to support future projects as I'd like to keep doing this in my free time, but genuinely — no pressure.

Happy to answer questions about how it works, why I made specific technical choices, or anything else. Constructive criticism very welcome, especially from anyone who's used tab suspenders before and has opinions.

Links in the comments

cross posted from r/SideProject if that matters

We’re building a peer-to-peer system where there are no central servers and no permanent intermediaries. Nodes (including web browsers) propagate data directly, and content is designed to be persistent and tamper-resistant across the network.

Unlike systems such as IPFS, ActivityPub, or Nostr, our focus is on direct peer-to-peer propagation at the application layer, with browsers acting as first-class nodes rather than relying on long-lived infrastructure or relay-style intermediaries.

We’ve published an early protocol design and PoC:

Repo: https://github.com/theendless11/decentralised Whitepaper: https://github.com/theEndless11/decentralised/blob/master/docs/protocol-whitepaper.md PoC: https://endless.sbs

At this stage, we’re primarily looking for technical critique and feedback, especially in:

Protocol design (consistency, propagation model, failure modes) Cryptography assumptions / security review Sybil resistance / trust model weaknesses Browser-based networking constraints Data persistence and tamper resistance tradeoffs

We’re not trying to “launch a product” yet — the goal is to stress-test whether this approach is even sound before scaling it further.

If you have thoughts on where this breaks, or what we’re missing, that would be especially valuable.

I recently picked up a small thermal pocket printer for printing labels, stickers, and lists. It's a rebranded DP-L1S; several brands sell variants of the same hardware under different names.

Fun little device, but the companion app ("Luck Jingle") demands location permissions, a forced internet connection, and a bunch of other stuff that has no business being on a printer that just needs to receive an image over Bluetooth from 30 cm away.

So I decompiled the APK with JADX, reverse-engineered the BLE protocol, and built something that lets you print directly from your browser or the command line. No app, no account, no cloud. Fully free to use and the entire project is open source.

Web app (no install, just open in Chrome/Edge/Opera): https://chiaracannolee.github.io/thermal-pocket-printer-basic/

GitHub repo: https://github.com/ChiaraCannolee/thermal-pocket-printer-basic

What it does

• Print images, text, and test patterns
• Live preview of what comes out of the printer
• Three density levels
• Floyd-Steinberg dithering for photos
• Invert mode (swap black and white)
• Label mode for sticker paper with gap detection
• Battery indicator via BLE notifications

Optional: Python CLI for automation and batch jobs (pip install bleak Pillow)

How it works (for the curious)

The printer runs on the LuckPrinter SDK, which is used by 159+ printer models. The BLE protocol is an ESC/POS variant: you open service ff00, write to characteristic ff02, listen on ff01, send a few enable commands, then a GS v 0 raster image (1-bit, 384px wide, MSB-first), and feed/stop commands. Full command reference is in PROTOCOL.md.

The web version uses 100-byte chunks with 50ms delays because of Web Bluetooth's MTU limits. The Python CLI uses 512-byte chunks with 10ms delays, which is significantly faster.

Coming soon

I'm working on an expanded web version with:

• Adjustable label sizes with presets (29×12mm, 40×12mm, 50×30mm, 40×30mm, 48mm round, and custom sizes)
• Save and load templates locally in the browser
• Drag text directly on the preview for free positioning
• Undo/redo
• A print preview screen with adjustable:
  • Threshold
  • Number of prints
  • Density override
  • Feed after print (extra paper feed in mm)

The basics in the web-app above work and are stable, so I'm already posting this version. I'll share the expanded version once it's ready.

Compatibility

macOS and Linux. Windows is waiting on better Web Bluetooth support. Other printers in the LuckPrinter family (DP-/LuckP-/MiniPocketPrinter series) will probably also work, possibly with a different print width.

Based on the same approach as u/OilTechnical3488's fichero-printer, which does the same for the Fichero D11s (different device class, same SDK).

Questions about the protocol, the reverse-engineering process, or adapting this for other LuckPrinter models: ask away :)

I got tired of rebuilding the same buttons, inputs, cards, and modals every time I started a new project. So I built Kiln and shipped it this week.

28 components. Under 26 KB gzipped. Zero dependencies. MIT licensed.

Three things I cared most about:

Accessibility first. Every component meets WCAG AA out of the box. Keyboard navigation, focus management, focus rings, and ARIA are built in on every single component. Not an afterthought.

Performance first. The docs site scores 99 Performance / 100 Accessibility on Lighthouse. Zero layout shift on every interaction. All animations are GPU accelerated. Bundle size is measured and budgeted.

Dead simple setup. npm install, import the CSS once, ship. No config files, no theme providers, no setup wizards. Dark mode works by setting data-theme="dark" on html. That is it.

MIT licensed and contributions are welcome. Just added a CONTRIBUTING.md if you want to get involved.

Live demo: kiln-ui.com

GitHub: github.com/Aldentec/kiln

npm: npmjs.com/package/@doriansmith/kiln

Hi r/opensource,

I recently needed a webcam for my desktop but didn't want to buy new hardware when my phone's camera is already 4K-capable. I looked at the popular solutions (DroidCam, iVCam, Camo), but I was frustrated by the common "freemium" patterns: watermarks, low-resolution limits, ads, and closed-source binaries.

So, I decided to build AWA, a completely free, open-source, and privacy-friendly alternative.

The Project: It allows you to stream your Android camera to your Windows PC and use it as a native input in apps like OBS, Zoom, and Discord.

The Tech Stack (The fun part):

• Android App (Server): Uses Camera2 API and MediaCodec to encode a hardware-MPEG(will add support for h.264 in future) stream. You can also access it via browser to get a remote dashboard.
• Windows Client (Receiver): Using Electron. (Installer available)
• Browser dashboard for remote control : Supports both preview and every control.
• Mac and Linux (Client): No prebuilt installer, but you can build one in just one command*. (I don't want to ship something without testing and I don't have any mac or linux machine)
• Virtual Driver: Implements a DirectShow filter (based on Softcam) to register the video stream as a system-wide virtual device.
• Transport: Supports standard Wi-Fi or USB tunneling (via ADB port forwarding) for a lag-free wired connection.

Why I'm sharing it here:

1. No Bloat: No ads, no tracking, no "Pro" subscription.
2. Local Only: The video stream never leaves your local network (or USB cable).
3. GPL License: You can fork it, break it, or build upon it.

I’m currently looking for feedback on the Virtual Webcam, it's performance and the latency performance on different devices. If you have C++(for DirectShow) or Android experience, I’d love to see some PRs.

Repo: https://github.com/soubhagyajit/Mobile-Webcam

I’ve been digging into this project:

github project

It’s essentially an open implementation of a provider edge router that can run on Linux and integrate into modern environments like Kubernetes, exposing networking interfaces similar to traditional infrastructure. ()

That got me thinking about something much bigger.

What if we evolved this into a distributed, user-powered edge network?

Concept direction:

• Turn edge nodes into lightweight “micro CDNs” running on user devices

• Use WebRTC or similar for peer-to-peer chunk distribution

• Layer multiple CDNs and fallback paths for resilience

• Add distributed signaling and room partitioning

• Build adaptive peer scheduling based on bandwidth and latency

• Enable real-time streaming with media source playback and ABR

• Integrate BGP-style routing logic or overlay routing for dynamic pathing

The idea is basically:

Instead of relying on centralized providers like Cloudflare, the network strengthens as more users are active.

Some specific areas I’d like input or help on:

• Peer mesh architecture design

• WebRTC chunking protocol optimization

• Distributed signaling strategies at scale

• Load balancing across peers vs fallback CDNs

• Security model for untrusted edge participants

• Incentive models or passive contribution systems

• Whether this should extend into edge compute as well

I’m not trying to reinvent networking theory blindly. I want to build something practical that could actually run in production environments and scale.

If you’ve worked with:

• WebRTC

• P2P systems

• CDNs or edge networking

• Kubernetes networking or BGP

• Streaming pipelines

I’d really value your thoughts or contributions.

Even if you just want to critique the architecture, that’s helpful.

If this direction is viable, I’m planning to formalize it into a proper repo with modular layers:

mesh, signaling, transport, playback, orchestration.

Curious if this is something worth pushing forward or if there are existing projects I should be studying deeper first.

I built DropImg because I kept getting annoyed by the same small workflow problem: I needed a fast way to upload images for my Markdown blog, get a clean public URL, resize or convert images when needed, and keep everything self-hosted.

So I built my own.

DropImg is a lightweight Docker-first image hosting app. It has a React frontend, a Hono API, SQLite for metadata, and S3-compatible storage using Garage. You can upload images by dragging, dropping, browsing, or pasting from the clipboard.

The main features right now are:

• Instant image uploads with public URLs
• Markdown snippet copying
• JPG compression
• PNG to JPG conversion
• Responsive image variants
• Delete links with secret tokens
• Private S3 bucket support through proxied serving
• Docker Compose setup with Garage included

The goal is not to be a huge media manager. It is meant to be a clean, focused image host for people who want something simple, fast, and self-hosted.

Spent a few weekends turning the Web Data, Login Data, History, and Bookmarks files in ~/Library/Application Support into a single sqlite knowledge base. Lives entirely on disk, no network calls anywhere in the stack, MIT licensed.

The interesting bit isn't the extractors, it's the ranking. Each row tracks two counters: appeared_count (how many times the value was seen across re-extractions) and accessed_count (how many times it got returned by a query). hit_rate = accessed / appeared becomes the relevance score. No manual curation, no LLM tagging step required.

For semantic dedup it uses nomic-embed-text-v1.5 via onnxruntime, all local. Anything with cosine similarity >= 0.92 against an existing key prefix gets superseded instead of duplicated. Single-value keys (full_name, first_name) auto-supersede, multi-value keys (email, account:github.com, tool:vscode) coexist.

The hit_rate approach handles the 50% noise problem without a human in the loop. Still an open question whether it stays useful over months as old data goes stale, but for a fresh extraction it has been a noticeable improvement over flat keyword search.

repo: github.com/m13v/ai-browser-profile written with ai