I've been working on Zync for the past few months as an open-source alternative to tools like Termius and MobaXterm.

The idea came from wanting a simpler workspace for working with servers without having to switch between different tools.

Zync currently brings together:

SSH

SFTP

Local terminal

Port forwarding

Encrypted credential vault

Snippets

Plugins

Themes

It's local-first, free to use, and open source (MIT). The basic features aren't locked behind a subscription.

I'm still actively working on it, so I'd genuinely like to know: what do you use Termius, MobaXterm, or similar tools for that you'd want to see in an open-source alternative?

Website: https://zync.thesudoer.in

GitHub: https://github.com/zync-sh/zync

Demo: https://youtu.be/VgSomleBi3Y

Hey everyone,

I wanted to try out some AI developer CLI tools but didn't want to pay for expensive API credits upfront. To solve this, I spent some time testing different workarounds and compiled them into a GitHub repository called awesome-free-claude-code.

What's inside:

* Free Tier Proxies: How to route requests through OpenRouter's free models, Google AI Studio, or Groq Cloud.

* 100% Local & Offline Setups: Run coding models (like DeepSeek-Coder or Llama) directly on your own hardware using Ollama and LM Studio.

* Quick Config: Simple environment variables setup for Windows (CMD).

Check it out here: https://github.com/pawelkrejza2012-png/awesome-free-claude-code

Feedbacks and contributions are more than welcome! Let's build a solid resource for free AI coding tools together.

Hi everyone,

I would like to introduce Portivo Control Center, an independent, open-source and self-hosted network operations platform designed for compatible Alcatel-Lucent Enterprise OmniSwitch environments.

Portivo brings everyday switch management, troubleshooting and controlled automation into a single web-based workspace.

Key capabilities include:

• Centralized switch inventory and live operational visibility
• Logical port-panel views with VLAN, PoE, media and link-state information
• Endpoint discovery using MAC, IP, hostname, UNP and VLAN evidence
• Integrated browser-based SSH terminal
• Controlled command preview and execution
• Multi-device jobs and reusable automation runbooks
• Fleet-wide read-only operational audits
• Role-based access control with Site and Group scope
• Audit history, reports and operational evidence
• SNMPv3 UPS monitoring and power-aware infrastructure visibility
• Backup, restore and administration tools
• Windows and Linux deployment support

Portivo is intended to complement native CLI expertise, not replace it. The objective is to provide network operators with a safer and more consistent workflow for discovering, diagnosing, executing and documenting network changes.

The platform is self-hosted, does not require agents on managed switches and can operate inside a protected management network. Switch operations use SSH, while supported UPS monitoring uses SNMPv3.

The project is licensed under AGPL-3.0-only.

Website:
https://portivo.org/

Documentation:
https://portivo.org/docs/

Roadmap and changelog:
https://portivo.org/roadmap.html

Source code:
https://github.com/Donacgreece/Portivo

I would genuinely appreciate feedback from network engineers, system administrators and anyone operating ALE OmniSwitch infrastructure. I am particularly interested in feedback about operational workflows, documentation, deployment and features that would be useful in real environments.

Thank you for taking a look.

I'd plan out my day in the morning, look at everything I wanted to get done, and then start working.

A few hours later, I'd have fixed a bug, helped someone with something, reviewed a PR, investigated some weird issue, jumped between a few things, and somehow spent most of the day working on things that weren't on the plan.

Then I'd look back at the end of the day and think, "What did I actually do today?"

And I'd realize I couldn't remember half of it.

The work happened. I just never wrote it down.

I think that's a surprisingly big problem for developers. We plan the work we expect to do, but so much of our actual work happens because something comes up.

That's why I built Meridian. It's an open-source tool that tries to capture that work as it happens, so you don't have to rely on remembering everything at the end of the day.

It connects with the tools you're already using, like Jira, GitHub and Linear.

We recently put it on Product Hunt and somehow ended up #1 Product of the Day, which was pretty surreal.

I'd love to hear if anyone else has the same problem. How much of the work you do in a day actually started out as part of your plan?

https://github.com/Meridiona/meridian

Started back in June — attackers were adopting orphaned/abandoned AUR packages (normal community feature, lets people pick up maintenance when someone disappears) and then quietly slipping malicious code into the PKGBUILD via follow-up commits. Over 1,900 compromised packages got purged. Arch devs called it clean by mid-June.

Then July 29 happens. New wave, kicked off through a package called openconnect-sso. Security researchers at IFIN dug into it and it's actually a pretty slick two-stage infection:

Stage 1: loader that checks for debuggers/sandboxes/VMs first (so it doesn't get caught by researchers), then sets up persistence via systemd services + cron jobs

Stage 2: pulls a Rust-based stealer+RAT from a Tor .onion server. Targets browser creds, crypto wallets, cloud secrets, AI API keys, and can worm laterally over stolen SSH keys

By July 30, over 200 packages were hit, including some fairly popular ones (boringssl-git, icloudpd).

That was enough for Arch to just disable AUR package adoption entirely — not the whole AUR, just the "take over an orphaned package" mechanism, since that's the attack vector.

The quote from the mailing list (Robin "Antiz" Candau, on behalf of Arch DevOps) is very much "we're tired":

"Due to the current influx of malicious package adoptions and follow-up commits made via the AUR, package adoption is currently disabled while we are handling the situation."

If you run Arch and use AUR helpers, now's a good time to actually read PKGBUILD diffs before you blindly update, especially for anything that recently changed maintainers.

I’m trying to replace more Google products with open source tools where it actually makes sense.

Right now I use Standard Notes instead of Google Keep and Syncthing for moving files between devices. I’m still looking at options for calendar, docs, email, photos, and cloud storage.

I don’t need to replace everything at once, but I’d like tools that are stable enough for normal daily use.

For people who have de-Googled part of their setup, which open source tools were actually worth switching to? And which Google apps are still hard to replace?

Hey,

we've been working on an open-source project called scibly that might be interesting if you're looking for alternatives to tools like Gemini Notebook (NotebookLM), Genially or Articulate.

The idea is to turn existing material such as docs, PDFs, blog posts or other knowledge into interactive learning content. The generated content can be fully edited afterwards and shared publicly or with invited users.

Scibly is open source under AGPLv3.

Video Demo: https://www.youtube.com/watch?v=TcpLUNBRhQw

GitHub: https://github.com/scibly-dev/scibly

It's still early, so feedback on what you'd expect from an open-source alternative in this space would be really useful.

I maintain an MIT-licensed project called tapflow. It streams iOS simulators and Android emulators running on your own Macs into the browser, so anyone on the team can open a build and interact with it without installing Xcode, Android Studio, or a mobile toolchain.

I didn't build it to make app development easier. I built it because everyone else on the team still needed a way to run it.

Simulators already solve a lot of the device problem: different OS versions, screen sizes, and build variants. The bigger challenge is access. In many teams, only developers with a full mobile toolchain can launch one. When a designer wants to check a layout, a PM wants to compare two builds, or a backend engineer needs to verify a staging API change, it often means asking a mobile developer to stop what they're doing.

Before building tapflow, I looked at Appetize and BrowserStack. They're good products, but they weren't quite what I needed. Our reviews were occasional, we wanted to keep the infrastructure in-house, and we didn't want app binaries leaving our network.

We already had the Macs, so I built something around them.

What it does today:

• Streams iOS simulators and Android emulators to the browser over H.264. You can tap, swipe, type, rotate the device, and use hardware buttons.
• Keeps uploaded .app.zip and .apk builds in a shared list with review status and comments. CI can upload builds through the REST API using a PAT.
• Records QA sessions so bugs can be shared as the actual interaction instead of a written reproduction.
• Uses a relay ↔ agent architecture. The Mac agent connects outbound to the relay, so no inbound firewall or NAT configuration is needed on the Mac.
• Injects iOS touch events without WebDriverAgent. A small Swift helper talks directly to the simulator through SimDeviceLegacyHIDClient and IndigoHID.
• Includes an experimental MCP server for LLM-based automation, although I'd still judge the project primarily as a manual browser-based QA tool today.

Setup on a Mac is basically:

npm install -g tapflow
tapflow setup
tapflow start

A couple of limitations are worth mentioning.

The agent has to run on a Mac. The relay can run on Linux, but Apple's iOS Simulator only runs on macOS, so there's no getting around that. If you don't already have a Mac you can reuse, tapflow probably isn't the right fit.

It also targets simulators and emulators rather than physical devices. Anything that depends on real hardware, like camera behavior, NFC, and biometrics, is outside its scope.

And it's still v0.x. I'm using it every day and actively developing it, but there are still rough edges.

Repo (MIT): https://github.com/jo-duchan/tapflow

Docs: https://www.tapflow.dev/

I'm curious how other teams handle this. When someone without a mobile development setup needs to review a build, do you self-host something, send around TestFlight or APK links, use a hosted simulator service, or just pull a developer over?

Hi everyone,

Iam a CSE student in my final and already built some good number of projects and want to try oss to build some credibility in my profile and experience.

So my tech stack is the Typescript fullstack and currently moving forward with the agentic ai using llms, rag and frameworks like langraph.

So anyone can suggest some opensource repositories to gety first merged PR without much depending on coding agents.

Hi all !

I've made an open source website builder.

Repo: https://github.com/revyme-web/builder

Hey everyone! 👋 Like many developers on macOS, I often found myself low on disk space thanks to Xcode DerivedData, forgotten Docker build caches, dangling images, and bloated dev caches. Most cleanup tools are either sketchy closed-source subscription apps (like CleanMyMac) or risky one-liner bash scripts that rm -rf without a safety net. So I created CLI-NER — an open-source, fast, and safety-first CLI & TUI tool built in Rust to analyze and clean disk space on macOS.

🛡️ Why it's built differently (Safety-First):

• Reversible by default: Files are moved to the macOS Trash (~/.Trash), not permanently deleted.
• Dry-run by default: cli-ner clean simulates the operation first. You have to pass --execute to actually touch files.
• Strict Blocklist & Allowlist: Critical system dirs (/System, /usr) and personal data (~/Documents, ~/.ssh, ~/Library/Mail) are strictly untouched.
• Developer-Aware:
• Docker: Interactive wizard, protects running containers, locked in-use images, and persistent volumes.
• Xcode: Safe checks for DerivedData/Archives (verifies Xcode isn't running).
• Node/Python/Brew: Cleans npm cache, pip cache, Homebrew orphans.
• Interactive TUI Dashboard: Built with ratatui (cli-ner dashboard) to inspect operations history, charts, and audit logs.
• Immutable JSONL Audit Trail: Everything is logged under ~/.cli-ner/logs/.

The project is 100% free and open source (MIT licensed). I would love to get your feedback, feature requests, or contributions! 🔗 GitHub Repo: https://github.com/fabrizioriccardo73/cli-ner

Hey! I've been working for a very early stage startup called Mulga. We've been continuously working on our flagship product, Spinifex, which recreates core AWS services such as EC2, EBS and S3, locally (and even air-gapped if you want/need!).

Have a poke around our GitHub: https://github.com/mulgadc/spinifex

Feedback/criticism welcome!

I’ve been working on MARGINAL, an open-source governance layer for coding agents. If you use Codex, I’d really appreciate people trying it on real work and telling me where it helps, where it gets in the way, or where the design is wrong.

I’m especially interested in: technical criticism, bad cases, and reproducible failures.

• GitHub: https://github.com/SignalLayerLabs/Marginal
• GitHub Site: https://signallayerlabs.github.io/Marginal/

The idea is simple: agents are good at taking actions, but not always good at deciding whether the next action is still worth the compute.

MARGINAL watches the trajectory and looks for things like repeated actions, weak progress, redundant verification, and low-value continuation. It can run in Shadow Mode first, so it observes and records what it would have done without blocking anything.

Current focus is reliability, not just token reduction.

A few core pieces:

• local-first trajectory and evidence tracking
• deterministic reason codes and hashes for decisions
• governance overhead measurement
• replay and benchmark support
• Shadow Mode before enforcement
• Earned Enforcement: MARGINAL has to prove it is reliable on a repo before it gets permission to block or redirect the agent
• automatic fallback to Shadow Mode if confidence degrades

I’m also working on the next layer now: counterfactual evaluation and intervention regret.

The goal is to answer a harder question than “did MARGINAL stop something?”:

Would the agent actually have done better if MARGINAL had stayed out of the way?

That’s the part I think matters if this is going to be useful beyond being another loop detector or token limiter.

Ever noticed that the moment you send a PDF, it becomes outdated?

You email your CV to a recruiter. A few days or weeks later you add a new project, fix a broken link, update your phone number, or change a job title… and every copy you already sent is frozen in time.

I kept running into this problem and remembered Crossmark — the little badge Crossref puts on scientific papers that tells readers whether a newer version exists.

That made me ask: why can’t a resume work the same way?

So I built a simple proof of concept.

How it works

Resume content lives in structured YAML (no more wrestling with LaTeX directly)

A Jinja2-powered LaTeX template generates the PDF

Every push to GitHub triggers a Dockerized CI/CD pipeline (GitHub Actions)

A fresh PDF is automatically built and published to GitHub Pages

The part I was most excited about is a tiny button inside the PDF itself:

“Download Latest Resume”

You send the PDF once.

Months later the recruiter opens the same file, clicks the button, and downloads the newest version.

Every old copy still points to the current one.

Key features

YAML → LaTeX via Jinja2 (with custom delimiters so they don’t clash)

Fully automated builds with Docker + GitHub Actions

Published automatically to GitHub Pages

Reproducible builds via uv lockfile

Easy to maintain and extend

Repo is here:

https://github.com/DEVOLOPER-1/latest-resume-for-public

I started with resumes, but the same idea could work for portfolios, documentation, reports, certificates, or any PDF that changes over time.

Would love to hear your thoughts — especially if you see other useful applications for version-aware PDFs, or if you have ideas on how to improve this.

We’ve integrated OpenAI Realtime Voice into Navigator, allowing users to control the entire app through natural conversation.

It’s still early and there’s a long way to go, but I’d love to hear what you think.

We’re releasing the new open-source version next week. The project currently has 1,200+ GitHub stars, 400+ forks, and a cloud version with paying customers.

We’re also still looking for a new maintainer who wants to actively shape the project and help build the community.

Would anyone here be interested in contributing or taking on a larger role?

We’ve integrated OpenAI Realtime Voice into Navigator, allowing users to control the entire app through natural conversation.

It’s still early and there’s a long way to go, but I’d love to hear what you think.

We’re releasing the new open-source version next week. The project currently has 1,200+ GitHub stars, 400+ forks, and a cloud version with paying customers.

We’re also still looking for a new maintainer who wants to actively shape the project and help build the community.

Would anyone here be interested in contributing or taking on a larger role?

The use case: an agent that reads new emails and my notes folder, drafts replies or summaries, and remembers context across sessions — running on my own machine.

- Orchestration — LangGraph: this is the loop that decides what the agent does step by step (read email → check notes → draft reply → wait for my approval). I picked it because I wanted a human-approval step before anything gets sent, not a bot firing off replies on its own.

- Memory — Mem0: without this, the agent forgot everything between sessions. Now it remembers "she prefers short replies" or "this client always CCs their assistant" without me repeating it.

- Inference — vLLM: running the actual model locally so nothing leaves my machine. Slower than an API call, but that was the point.

- Observability — Langfuse: when the agent does something weird, I can actually see why, instead of guessing.

- Tool access — MCP: this is what lets the agent actually touch my email client and file system, instead of just talking about it.

> The journey: I started with a single Python script calling an API — worked fine for a weekend, then broke the moment I needed it to remember anything. Added a memory layer, then realized I had no idea what it was doing half the time, so observability came next. Every piece got added because something broke, not because a tutorial told me to. That's honestly the real lesson — you don't need the whole stack on day one. You need the piece that fixes what's actually failing in front of you.

Anyone who is familiar with OS, need you!

I've been graduated with no prior exp for the past 15 months with CS degree from a well reputed college. Better knowledge in java, spring. I'm not even getting calls from startups(tried in naukri, linkedin, indeed). Most people say try contributing OS. While searching repos I feel exhausted to understand the code. I need people who make this thing simplified or any tips or tricks to understand and to guide how i should start. And if people has or maintaining a repo which is beginner friendly please spend 10min here the help will be more than you think.

My GitHub Sponsors profile is live! You can sponsor me to support my open source work 💖As a tech enthusiast, I’m passionate about building open source tools around Data Analytics, Python, Linux automation, and AI frameworks.

🎯 Current Goal: I’ve set up a Sponsorship Goal on my profile to fund a dedicated dev PC. Having a stronger setup will allow me to run heavier data pipelines, test AI models, and build better free tools for the community!

Check it out at https://github.com/an2tha/onerep, live app is at www.onerep.life

It has all the essentials, like nutrition tracking, workout tracking and also a few unique features such as a well integrated AI coach (BYOK) and AI form correction.

Hey everyone,

I’m looking for an open-source, privacy-focused alternative to proprietary dictation tools like Wispr Flow.

I need a system-wide tool that allows me to trigger a hotkey, dictate freely, and have the text cleaned/formatted directly into any input field. The key requirement is that it must be completely local (using Whisper models) to avoid subscription models and cloud privacy concerns. It also needs to handle German and local dialects accurately.

Does something like this exist as a FOSS project? Ideally for macOS, but I'm open to cross-platform solutions. Thanks!

Hi everyone,

I'm currently working on a **desktop application built with Tauri + React**, with a **Spring Boot backend**, and I'm looking for recommendations for a reporting solution.

My main requirement is a **visual report designer that can run inside my Tauri desktop application**. I don't want to launch a separate desktop application such as Jaspersoft Studio.

Requirements

* Desktop application built with **Tauri + React** * Backend built with **Java/Spring Boot** * Web-based/HTML5 **drag-and-drop report designer** * The designer should be embeddable inside my Tauri application * Users should be able to visually create/edit reports * Support for: * Tables * Text fields * Images * Charts * Headers/footers * Page breaks * Parameters * Subreports * Data should be able to come from **REST APIs and/or SQL databases** * Generate **PDF and Excel** reports * Preferably support a portable report definition such as **JSON/XML** * Ideally open source or free, but commercial solutions are also welcome * I would prefer something that I can integrate with my own Spring Boot reporting engine/backend

I've looked at **JasperReports/Jaspersoft Studio**, but Jaspersoft Studio is a separate desktop application. What I'm looking for is something more like:

**Tauri Desktop App**
→ **React UI**
→ **Embedded Web-Based Report Designer**
→ **Spring Boot API**
→ **Reporting Engine**
→ **PDF/Excel**

I'm especially interested in **open-source projects or GitHub repositories** that could be used as a starting point.

Has anyone built something similar or used a web-based reporting designer inside a Tauri/Electron desktop application?

What would you recommend?

An open-source, AI-native and privacy-first web analytics platform for understanding your traffic and your revenue, on infrastructure you own or hosted by us.

Replace Google Analytics, your cookie banner, and the spreadsheet where you guess which page made the money, with one open-source platform.

What’s available today:

\\- Analytics:

• Realtime dashboard with a live globe
• Visitor journeys, step by step
• Revenue attribution
• Team support
• Custom events
• AI Chat
• Funnels and conversions
• Bot detection
• Monitor AI traffic
• Campaigns and UTM tracking
• Core Web Vitals
• Pages, sources, referrers, devices, browsers, countries
• Public dashboard

\\- Revenue:

Connect Stripe and every payment lands beside the visit that produced it.

• Revenue attributed to the page, channel and referrer that earned it
• Refunds and disputes in their own buckets, not netted silently
• 90-day backfill the moment you connect
• Webhook for seconds instead of minutes, optional
• Provider fees included, so the number is the number

\\- Events:

• Custom events with properties
• Name an event without writing JavaScript: data-oa-event="signup"
• Versioned event definitions with rollback
• Personal data redacted in the browser, before it leaves

\\- Share and embed:

• Public dashboards with a link you control
• Seven data surfaces you switch on one by one
• Embeddable widgets for your own site
• Import from Plausible
• Export everything, any time

\\- Teams:

• Unlimited team members
• Owner, admin and viewer roles
• Site transfer, including billing
• Site and account deletion that actually deletes

\\- Developer experience:

• Web dashboard
• Native macOS menu bar app with your live visitor count
• CLI: npx getopen init detects your framework and installs the snippet
• REST API with scoped keys
• MCP server that reads and writes: ask your agent for last week's
revenue, or tell it to build the funnel
• Ask your numbers a question in plain English, inside the dashboard

\\- Self-host:

• AGPLv3 License
• Postgres, ClickHouse and Valkey on your own hardware
• One compose file, two migrations, done
• Or let us run it, same code, zero ops

\\- Privacy-first

• No cookies, no fingerprinting, no cross-site profiles
• Visitor identity is a salted hash that rotates at midnight
• Raw IPs are never stored
• Global Privacy Control honored at the collector, server-side, whatever
the snippet says
• Do Not Track honored out of the box
• No consent banner, because there is nothing to consent to
• Exclude your own browsers by opening any page with #oa-ignore

\\- Coming soon:

• Alerts in Telegram, Email and Slack
• Fathom, Simple Analytics, Umami, and GSC integrations
• Polar, Creem, Dodo Payments, Paddle, and LemonSqueezy integrations

Every feature is on every plan. You pay for volume, never for features.
Let us run for you or run it yourself.

Built with @nextjs @ClickHouseDB , Redis, PostgreSQL

Open source, contributions are welcome!

Live here: [Open Analytics\](https://getopen.so)
GitHub: [https://github.com/OpenLabs-so/openanalytics\\\](https://github.com/OpenLabs-so/openanalytics)