When you have software out in the wild being used by lots of people, it’s inevitable that there will be pretty large spread across the versions of your software being used.

If that software is aimed towards technical folks and power users, or if you publish nightly releases, in addition to the spread across official version releases, you will also have many people running on any number of commit hashes.

If you dual-license your software in such a way that it requires a paid license for commercial use, here are two code blobs for you.

macOS

pub fn mdm_enrollment() -> eyre::Result<(bool, Option<String>)> {
    let mut command = Command::new("/usr/bin/profiles");
    command.args(["status", "-type", "enrollment"]);
    let stdout = command.output()?.stdout;
    let output = std::str::from_utf8(&stdout)?;
    if output.contains("MDM enrollment: No") {
        return Ok((false, None));
    }

    let mut server = None;

    for line in output.lines() {
        if line.starts_with("MDM server") {
            server = Some(line.trim_start_matches("MDM server: ").to_string())
        }
    }

    Ok((true, server))
}

Windows

pub fn mdm_enrollment() -> eyre::Result<(bool, Option<String>)> {
    let mut command = Command::new("dsregcmd");
    command.args(["/status"]);
    let stdout = command.output()?.stdout;
    let output = std::str::from_utf8(&stdout)?;
    if !output.contains("MdmUrl") {
        return Ok((false, None));
    }

    let mut server = None;

    for line in output.lines() {
        if line.contains("MdmUrl") {
            let line = line.trim().to_string();
            server = Some(line.trim_start_matches("MdmUrl : ").to_string())
        }
    }

    Ok((true, server))
}

Looking at mobile device management (MDM) enrollment is not a silver bullet for identifying corporate devices running your software, but it is a good start.

Building for macOS has been… interesting. After falling into the trap of Microsoft’s 10x price gouging for macOS runners on GitHub Actions and ultimately switching to using the Mac Mini under my television as a self-hosted runner, the next thing I wanted to do was distribute my build artifacts.

I’m trying a different approach to building a new project this time around. Maintaining a popular piece of software is very draining, and working on a much-requested port of a popular piece of software to another operating system was not something I wanted to do in public.

One of the great things about building your own tools is that you get to have your desired workflow and user experience with very few compromises.

I built Notado because I wanted an archiving and highlighting workflow which treated online comments as first class citizens.

I built Kullish because I wanted to be able to quickly aggregate comments about links from a variety of different online communities.

I built komorebi because I wanted a tiling window manager for Windows.

The JSON License famously includes a provision stating that “The Software shall be used for Good, not Evil”.

This article explores why such provisions are not useful or meaningful in the greater software licensing conversation.

“Evil” is largely part of the software licensing conversation today because of a much earlier line drawn in the sand by open source software licensing proponents demanding that compliant licenses permit use for “Evil” (and consequently, placing a hard restriction on the individual freedom to refuse).

There are two points of popular open source mythology this post will share my experience with:

• People won’t use your project if you don’t use an Open Source Initiative-approved license
• People won’t contribute to to your project if you don’t use an Open Source Initiative-approved license

Many people have ideas about how society should be like and what must be done to change institutions and to work for a revolution. But this is not enough. Often these ideas do not conform to reality and if they do conform to reality there is only one way to test them: Try to put them to work and see if they succeed. Testing our ideas in concrete work is the only way we will ever know if they are correct.

A program is educational source (edu source) software if:

• The source code is available to individuals for personal use, modification, learning and reference

komorebi is edu source software, and the Komorebi License is an edu source license.[1]

Any software license which ensures access to source code fulfils the criteria to be considered an edu source license.

[1]: In addition to being an edu source license, the Komorebi License is also a firewall license, which serves to protect an individual’s freedom to refuse by default.

You’re likely here because you’ve discovered that I generally refuse to use open source licenses for my popular software projects, and you want to engage me in a discussion.

Here is a list of things I consider before accepting an invitation from someone to engage in a discussion about why I do not use open source software licenses.

• Skin in the game - if you have not created, released, and maintained publicly developed software with a user base of a non-trivial size (10k+ users), you’re better off discussing software licensing in the abstract with others whose only hands-on experience is discussing software licensing in the abstract
• Acknowledgment of open source licensing’s genocide problem
• Proposals to address open source licensing’s genocide problem - if you do not consider open source licensing’s genocide problem to be a issue, then we don’t have any common ground for discussion

I made $901.49 in my first month selling commercial use software licenses.

This $901.49 came from 14 customers, 6 of whom purchased monthly license subscriptions and 8 of whom purchased annual license subscriptions.

My most popular piece of software, komorebi, is a tiling window manager for Windows, published under an educational source license which does not permit any kind of commercial use.

At the beginning of 2025, I started offering dedicated individual commercial use licenses for people who want to use it at work.

People who make useful content and services intended for interactive human use available for free have written at length about the ongoing issues with AI crawlers scouring the web in an insatiable search for new training data.

Some people are coming up with interesting technical solutions to the problems posed by AI crawlers, but I have ultimately opted for a much simpler solution: a paywall.

Kullish is a project that I operated free of charge for all users from 2020 until January 2025.