cross-posted from: https://lemmings.world/post/42484977

Pay securely with an Android smartphone, completely without Google services: This is the plan being developed by the newly founded industry consortium led by the German Volla Systeme GmbH. It is an open-source alternative to Google Play Integrity. This proprietary interface decides on Android smartphones with Google Play services whether banking, government, or wallet apps are allowed to run on a smartphone.

One of the things I discovered (or better said, something I suspected but had the chance to verify) while working on open-sourcing a tool (and API client tool): there is a big (mostly justified) trust deficiency out there .

I could feel it immediately in every discussion: always that little question in the back of people’s minds:

"Will this project "stay true", or will it change the rules on me later?"

We have seen this pattern repeatedly: Terraform > OpenTofu, Redis > Valkey, Elastic > OpenSearch....

I understand this: it’s becoming hard not to become a little cynical. In some ways, SaaS starts to feel better only because its more honest and at least the incentives and motivations are explicit from day one.

But why does this happen?

One answer is simple: bad intentions, that yeah, they do exist some times. But then this might be an oversimplification.

One aspect that is not often talked about: Many of the most durable open-source tools and frameworks (VS Code, React, Kubernetes, and Backstage among others) were built by companies where the tool itself was NOT the primary revenue engine. Their core business lived elsewhere.

This means that these tools could function as ecosystem infrastructure rather than direct monetization vehicles. They could stay open because they weren’t carrying payroll, sales targets, and investor expectations on their own.

In contrast, when an open-source project becomes the business, the incentives start to shift. The tool now has to "fund" teams, meet SLAs, satisfy investors, and deliver predictable growth.

Over time, that pressure often leads to open-core models, licensing changes, community forks, and growing tension between "community" and "enterprise."

So yeah, the intentions might have not been alway bad....but the economics have spoken...

The "open source first, monetize later" strategy feels super risky.

Once adoption takes off and the tool becomes central to a company’s survival, teams are forced into trade-offs that often erode trust and fragment communities.

My opinion is that Open Source thrives most easily when it IS NOT carrying the full weight of corporate survival.

When it is, preserving its original spirit becomes much harder.

If we want healthier developer ecosystems, we need to be more honest from the start. This means to either build an open-source project as genuine long-term infrastructure and commit to keeping it open, or build a commercial product with a clear monetization model from day one.

Both paths are valid. Trying to blur the two is what repeatedly leads to broken trust (with developers), frustrated contributors, and fragmented communities.

The takeaway? I guess it is that we just need to be upfront:

If your project is commercial lets be upfront. If it’s truly open, lets commit to it.

Anything in between makes people hesitate to believe and that’s how communities start to fracture.

what do you think? what makes you trust an open-source project long term, and what are the red flags that make you cautious?

The OpenWrt project has announced the release of OpenWrt 25.12, a free and open-source Linux-based operating system primarily used for embedded devices, most notably residential gateways and routers, as the first stable version in the new 25.12 series.

The main highlight is the switch from the opkg package manager to APK (Alpine Package Keeper). Since the OpenWrt opkg fork is no longer maintained, the project has adopted APK as the default package manager. While most package names remain the same, command-line syntax has changed. The project provides an official opkg-to-apk cheat sheet to assist users with the transition.

The newest open-source concern around AI that is seeing a lot of interest this weekend is when large language models / AI code generators may rewrite large parts of a codebase and then the "developers" claiming an alternative license incompatible with the original source license. This became a real concern this week with a popular Python project experiencing an AI-driven code rewrite and now published under an alternative license that its original author does not agree with and incompatible with the original code.

Chardet as a Python character encoding detector with its v7.0 release last week was a "ground-up, MIT-licensed rewrite of chardet." This rewrite was largely driven via AI/LLM and claims to be up to 41x faster and offer an array of new features. But with this AI-driven rewrite, the license shifted from the LGPL to MIT.

digiKam 9.0 has been officially released today as a massive update for this open-source, free, and cross-platform professional-grade photo management software for GNU/Linux, macOS, and Windows.

Highlights of digiKam 9.0 include a dedicated Qt 6 port for a more modern UI/UX experience across all supported platforms, along with a redesigned Welcome page in a more modern style, as well as completely revamped GUIs of the File Copy and File Transfer dialogs for better usability.

Color label names are now customizable in the Labels tab, regular expression wildcard support has been added for ignored directories settings, support for a customizable date format was added to display everywhere in the application, and a “Date Format” modifier was added to the Advanced Rename feature.

Our team are building an open-source IP/SIP intercom + video surveillance platform (GPLv3).

Core ideas

No vendor lock-in: designed to work with SIP intercoms and CCTV that expose an open API.

Modular setup: you can start small (a private house) and scale up to apartment buildings / residential complexes / districts / even a city.

What you can build

• IP/SIP intercom for entrances, gates, barriers
• Video surveillance (live + archive) with modern server-side + admin panel (we also maintain a built-in free media server (based on ffmpeg) for mobile live + archive access: Simple-DVR)
• Mobile apps for residents (iOS/Android)
• Desktop web client for security/concierge teams
• Ticketing & field service workflows (task tracking + planning + PWA for technicians)
• Optional face recognition + license plate recognition (FALPRS)
• Integrations with billing/CRM/payments and external systems

Localization

The project is currently localized for English, Russian, Kazakh, Uzbek, Bulgarian, Arabic, Armenian. If you’d like to help, we’d love contributions for new languages (translations, terminology review, UI copy improvements, etc.).

Repositories

• Server (RBT): https://github.com/rosteleset/SmartYard-Server
• Simple-DVR media server (live + archive): https://github.com/rosteleset/Simple-DVR
• iOS app: https://github.com/rosteleset/SmartYard-iOS
• Android app: https://github.com/rosteleset/SmartYard-Android
• FALPRS (faces + plates): https://github.com/rosteleset/falprs
• Fieldworker PWA (RBT-TT): https://github.com/rosteleset/SmartYard-TT-PWA
• Desktop web client: https://github.com/rosteleset/SmartYard-Vue
• Web extensions examples: https://github.com/rosteleset/SmartYard-web

Who this might be useful for

• ISPs / telecom operators
• property management companies
• intercom installation & service teams
• building owners who want an open source self-hosted platform

Invitation

You’re welcome to use this project for free to build your own ideas/products/solutions — and if you like it, I’d love to invite you to contribute (issues, PRs, docs, localization, testing with new SIP intercoms/cameras, integrations, packaging/deployment improvements, etc.).

If you’re interested, I’d really appreciate:

• feedback on the architecture and docs
• suggestions on what hardware models we should prioritize next
• contributors/users who want to try it in their environment

Thanks! 🙌

Write up by @sbca68@lemmy.world

From the WeeklyOSM Newsletter, I thought it deserved its own post

for those not familiar with Mark Pilgrim, he is/was a prolific author, blogger, and hacker who abruptly disappeared from the internet in 2011.

HN comments

see also https://fosdem.org/2026/schedule/event/SUVS7G-lets_end_open_source_together_with_this_one_simple_trick/

In the world of open source, relicensing is notoriously difficult. It usually requires the unanimous consent of every person who has ever contributed a line of code, a feat nearly impossible for legacy projects. chardet , a Python character encoding detector used by requests and many others, has sat in that tension for years: as a port of Mozilla’s C++ code it was bound to the LGPL, making it a gray area for corporate users and a headache for its most famous consumer.

Recently the maintainers used Claude Code to rewrite the whole codebase and release v7.0.0 , relicensing from LGPL to MIT in the process. The original author, a2mark , saw this as a potential GPL violation

EDIT: They want users to help generate a dataset. You just play a game and email them the data when you are done.

I just did it, it was easy.

As someone who loves both coding and language learning (I'm learning Japanese right now), I always wished there was a free, open-source tool for learning Japanese, just like Monkeytype in the typing community.

Here's the best part: I added a gazillion different color themes, fonts and other crazy customization options, inspired directly by Monkeytype. Also, I made the app resemble Duolingo, as that's what I'm using to learn Japanese at the moment and it's what a lot of language learners are already familiar with.

Miraculously, people loved the idea, and the project even managed to somehow hit 1k stars on GitHub now. Now, I'm looking to continue working on the project to see where I can take it next.

Back in January, I even applied to Vercel's open-source software sponsorship program as a joke. I didn't seriously expect to win, and did it more out of curiosity, fully expecting to lose.

Lo and behold, yesterday I woke up to an email saying the app has been accepted into Vercel's Winter cohort. Crazy! GitHub: https://github.com/lingdojo/kana-dojo

Anyway. Why am I doing all this? Because I'm a filthy weeb.

どうもありがとうございます!

By developer @tentoumushi@sopuli.xyz

In the previous post, JADEx introduced a new feature ~~Immutability~~.
Through community feedback, several confusions and limitations were identified.

In v0.42, we have addressed these issues and improved the feature. This post explains the key improvements and new additions in this release.

Improvements

~~apply immutability~~ -> apply readonly

• The previous term (Immutability) caused misunderstandings.
• Community feedback revealed that “Immutable” was interpreted differently by different developers, either as Deeply Immutable or Shallowly Immutable.
• In v0.42, we replaced it with readonly.
• Meaning: clearly indicates final by default, preventing reassignment of variables.

Expanded Scope of final keyword: now includes method parameters

• v0.41: final was applied only to fields + local variables
• v0.42: final is applied to fields + local variables + method parameters
• Method parameters are now readonly by default, preventing accidental reassignment inside methods.

Example Code

JADEx Source Code

package jadex.example;

apply readonly;

public class Readonly {

    private int capacity = 2; // readonly
    private String? msg = "readonly"; // readonly

    private int uninitializedCapacity; // error (uninitialized readonly)
    private String uninitializedMsg;    // error (uninitialized readonly)

    private mutable String? mutableMsg = "mutable";  // mutable

    public static void printMessages(String? mutableParam, String? readonlyParam) {

        mutableParam = "try to change"; // error
        readonlyParam = "try to change"; // error

        System.out.println("mutableParam: " + mutableParam);
        System.out.println("readonlyParam: " + readonlyParam);
    }

    public static void main(String[] args) {
        var readonly = new Readonly();
        String? mutableMsg = "changed mutable";

        readonly.capacity = 10; // error
        readonly.msg = "new readonly"; // error

        readonly.mutableMsg = mutableMsg;

        printMessages(readonly.msg, mutableMsg);

        System.out.println("mutableMsg: " + readonly.mutableMsg);
        System.out.println("capacity: " + readonly.capacity);
        System.out.println("msg: " + readonly.msg);
    }
}

Generated Java Code

package jadex.example;

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
import jadex.runtime.SafeAccess;

//apply readonly;

@NullMarked
public class Readonly {

    private final int capacity = 2; // readonly
    private final @Nullable String msg = "readonly"; // readonly

    private final int uninitializedCapacity; // error (uninitilaized readonly)
    private final String uninitializedMsg; // error (uninitilaized readonly)

    private @Nullable String mutableMsg = "mutable";  // mutable

    public static void printMessages(final @Nullable String mutableParam, final @Nullable String readonlyParam) {

        mutableParam = "try to change"; //error
        readonlyParam = "try to change"; //error

        System.out.println("mutableParam: " + mutableParam);
        System.out.println("readonlyParam: " + readonlyParam);
    }

    public static void main(final String[] args) {
        final var readonly = new Readonly();
        final @Nullable String mutableMsg = "changed mutable";

        readonly.capacity = 10; //error
        readonly.msg = "new readonly"; //error

        readonly.mutableMsg = mutableMsg;

        printMessages(readonly.msg, mutableMsg);

        System.out.println("mutableMsg: " + readonly.mutableMsg);
        System.out.println("capacity: " + readonly.capacity);
        System.out.println("msg: " + readonly.msg);
    }
}

New Additions

JSpecify @NullMarked Annotation Support

• All Java code generated by JADEx now includes the @NullMarked annotation.
• This improves Null-Safety along with readonly enforcement.

This feature is available starting from JADEx v0.42. Since the IntelliJ Plugin for JADEx v0.42 has not yet been published on the JetBrains Marketplace, if you wish to try it, please download the JADEx IntelliJ Plugin from the link below and install it manually.

JADEx v0.42 IntelliJ Plugin

We highly welcome your feedback on JADEx.

Thank you.