Software Licensing & Agreements — from open source to selling your own

Licensing is where software meets the law, and it decides what you and your users are actually allowed to do with code. This path is a plain-language, end-to-end tour — start with what a license is and how copyright makes software ownable, then work through every open-source license in detail (MIT, BSD, Apache, the GPL family, the weak-copyleft licenses, and public domain) with the real strengths, weaknesses, and trade-offs of each. From there you'll learn to choose and combine open-source licenses, how proprietary and commercial licensing works, how to write a custom license to sell software, and how to use open-source libraries inside a product you sell without breaking the rules. The back half teaches you to read any software agreement and understand it before you sign, covers the other agreements software needs — EULAs, terms of service, privacy policies, DPAs, SLAs, and NDAs — and ends by walking you through choosing the right license and the right set of agreements for your own software. Concepts are taught with US law as the reference point and the major differences in other jurisdictions flagged throughout, so you get the complete picture. This is educational material, not legal advice. No legal background required; examples lean on real software, including GopherTrunk's own Apache-2.0 license and dependency notices.

Start lesson 1 →Jump to glossary

“Software licensing” sounds like fine print, but it’s really the set of rules that decide who may use, copy, change, and sell a piece of code — including the code you write and the code you build on. Get it wrong and you can lose the right to ship, or hand away rights you meant to keep; get it right and you can share freely, sell confidently, and reuse the world’s open source without nasty surprises. This path builds that understanding one short lesson at a time, starting from what a license actually is and ending with a concrete plan for licensing and agreements around your own software.

Who this is for. Anyone who ships software and wants to handle the legal layer on purpose instead of by guesswork — developers picking a license for a side project, founders building a product on open-source components, and anyone who has to read an agreement before clicking “I agree”. No legal background is assumed, and every term is explained the first time it appears. If you’re brand new to building software, the Intro to Software Development path pairs naturally with this one; every lesson here is self-contained and cross-linked, so you can read straight through or jump to what you need.

How the path works. Seven modules move from foundations to doing. We open with the groundwork — what a license is, how copyright and the other intellectual-property rights work, how a license differs from a contract, and the full spectrum from public domain to closed source. From there we cover the open-source licenses in depth (MIT, BSD, Apache, the GPL family, the weak- copyleft licenses, and public-domain dedications), then how to choose and combine them safely. Module 4 turns to proprietary and commercial licensing, including writing a license to sell your own software; Module 5 tackles the question every founder asks — can you sell software built on open source? — and how to stay compliant. Module 6 teaches you to read agreements and the other documents users meet (EULAs, terms of service, privacy policies, SLAs, NDAs), and Module 7 turns all of it into a decision framework for your own projects. Throughout, we teach concepts first, use the United States as the reference jurisdiction while flagging how things differ elsewhere, and lean on real examples — including GopherTrunk’s own Apache-2.0 license and dependency attribution — to keep things concrete. One thing to keep in mind as you read: this is educational material, not legal advice, and decisions that carry real risk deserve a qualified attorney. Mark lessons complete as you go; your progress is saved in your browser. Start with lesson 1: What is a software license?

Module 1 — Licensing & IP Foundations

What a software license actually is, how copyright and other IP make code ownable, license versus contract, the full spectrum of license types, and how the law differs around the world.

  1. What is a software license? A license is permission to use code you don't own — why software defaults to "all rights reserved", what a license grants, and why every project needs one. beginner 9 min
  2. Copyright & software ownership How copyright attaches to code automatically, what it does and doesn't protect, and who actually owns software written by employees, contractors, and you. beginner 10 min
  3. Patents, trademarks & trade secrets Copyright isn't the only IP in software — how patents, trademarks, and trade secrets each touch your code, your name, and your competitive edge. beginner 10 min
  4. License vs contract A license grants permission; a contract is a deal with obligations on both sides — why the difference matters, and how click-wrap and browse-wrap agreements bind users. intermediate 9 min
  5. The licensing spectrum From locked-down proprietary to source-available to open source to public domain — the full map of how software can be licensed, and where each model fits. beginner 9 min
  6. Licensing across jurisdictions US copyright is the reference point, but moral rights, enforceability, warranty disclaimers, and data law differ worldwide — the complete cross-border picture. intermediate 11 min

Module 2 — Open Source Licenses in Depth

What 'open source' really means, the permissive-versus-copyleft divide, and a detailed look at every common license — MIT, BSD, Apache, GPL, AGPL, the weak-copyleft licenses, and public domain — with the real strengths and weaknesses of each.

  1. What open source really means The OSI Open Source Definition, the FSF's four freedoms, "free vs open", and why source-available is not the same as open source. beginner 10 min
  2. Permissive vs copyleft The single divide that organizes every open-source license — do nothing back, or share alike — and what "copyleft" really obligates. beginner 9 min
  3. MIT & BSD: minimal permissive The short, do-almost-anything licenses behind most of the ecosystem — what MIT and the BSD variants say, where they shine, and their few real weaknesses. beginner 9 min
  4. Apache 2.0: permissive with a patent grant Permissive freedom plus an explicit patent grant and NOTICE requirement — why Apache 2.0 is the corporate default, and why GopherTrunk uses it. intermediate 10 min
  5. The GPL: strong copyleft The license that started copyleft — what triggers GPLv2/v3 obligations, the source-code requirement, and the strengths and costs of "share alike". intermediate 11 min
  6. The AGPL: copyleft over the network How the AGPL closes the SaaS "loophole" by triggering on network use, why it protects user freedom, and why so many companies ban it outright. intermediate 9 min
  7. Weak copyleft: LGPL, MPL, EPL The middle ground — file- and library-level copyleft that lets you link from proprietary code while keeping the open parts open; strengths and traps of each. intermediate 10 min
  8. Public domain, Unlicense & CC0 Giving up all rights — public-domain dedications, the Unlicense, CC0, and 0BSD — plus why "no license at all" is a trap, not a gift. beginner 8 min

Module 3 — Choosing & Combining Open Source

Putting the licenses to work: how they combine and where they conflict, how to pick one for your own project, contributor agreements, dual licensing, and the long-term risks of depending on open source.

  1. License compatibility When code under different licenses can legally be combined, why GPL compatibility runs one way, and a mental model for the compatibility matrix. intermediate 10 min
  2. Choosing an open-source license Turning strengths and weaknesses into a decision — match your goals to a license, and the tools (choosealicense.com and friends) that help. intermediate 9 min
  3. Contributor agreements: CLAs & DCO How projects take in outside contributions cleanly — CLAs, the DCO, and "inbound=outbound" — and what every contributor should understand before signing. intermediate 9 min
  4. Dual licensing & relicensing Offering the same code as both open source and a paid license, what makes it possible (owning the copyright), and the constraints on changing a license later. advanced 9 min
  5. The risks of depending on open source License changes and "rug pulls", abandonment, supply-chain and provenance risk, and the audit and legal exposure that come with every dependency. intermediate 10 min

Module 4 — Proprietary & Commercial Licensing

The paid side of the spectrum: how proprietary licensing works, the commercial pricing models, source-available licenses, and how to write and price a custom license to sell your own software — plus where to get real help.

  1. Proprietary & closed-source licensing What a proprietary license restricts and why, from "all rights reserved" to reverse-engineering and redistribution clauses — the opposite end of open source. beginner 9 min
  2. Commercial license models Perpetual vs subscription, per-seat, per-core, usage-based, site and enterprise licenses, and OEM — the pricing structures behind software you pay for. intermediate 10 min
  3. Source-available & "fair source" BSL, SSPL, the Elastic License and "fair source" — why companies adopt them, what they actually allow, and why they are not open source. intermediate 9 min
  4. Writing a license to sell software Building a custom commercial license — the grant, scope, structure, and the decisions you must make first before any clause goes on the page. advanced 11 min
  5. Key clauses in a commercial license Warranty, limitation of liability, indemnity, IP ownership, termination, governing law, and audit rights — the clauses that decide who carries the risk. advanced 11 min
  6. Where to get licensing help When you genuinely need a lawyer, the reputable template and contract sources, the standards bodies, and the generators — where to find more information. beginner 8 min

Module 5 — Using Open Source in Software You Sell

You can absolutely build a paid product on open source — if you follow the rules. Meeting permissive obligations, handling copyleft and the 'viral' question, and auditing your dependencies so compliance is continuous, not a fire drill.

  1. Can you sell software built on open source? Yes — and here are the rules that make it legal. The obligations that come with every dependency, and the myths that scare people away from open source. beginner 9 min
  2. Meeting permissive obligations The attribution, license-text, and NOTICE requirements behind MIT, BSD, and Apache — modeled on GopherTrunk's own THIRD_PARTY_LICENSES.md. intermediate 9 min
  3. Copyleft in products: the viral question What actually triggers GPL, AGPL, and LGPL obligations in a product, where the linking and distribution boundaries fall, and the patterns that keep you safe. advanced 11 min
  4. Auditing dependencies & SBOMs Knowing every license you ship — dependency scanning, SBOMs, SPDX, the tooling (FOSSA, ScanCode, and friends), and building an ongoing compliance process. intermediate 10 min

Module 6 — Reading Agreements & Other User Agreements

How to actually read a software agreement and understand it before you sign — the main clauses, the risk clauses, and the red flags — then a tour of the other agreements software needs: EULAs, terms of service, privacy policies, DPAs, SLAs, and NDAs.

  1. How to read a software agreement A repeatable method for reading any license or agreement — following defined terms, mapping the structure, and extracting what actually matters to you. beginner 10 min
  2. The main clauses, decoded The clauses in nearly every software agreement — grant, scope, fees, term, confidentiality, IP — and what each one really means in plain language. intermediate 10 min
  3. The risk clauses: who pays when it breaks Warranty disclaimers, limitation of liability, indemnification, and "as-is" — the quiet clauses that decide who is on the hook when software fails. intermediate 10 min
  4. What to check before you agree A pre-signature checklist and the red flags — auto-renewal, price changes, data use, assignment, audit rights, and termination — to catch before you click "I agree". intermediate 10 min
  5. EULAs & terms of service The agreements your users accept — end-user license agreements and terms of service — what they cover, how they bind users, and the terms that matter most. beginner 9 min
  6. Privacy policies & data agreements Privacy policies, data processing agreements, GDPR and CCPA basics, and sub-processors — the data-side agreements most modern software is required to have. intermediate 10 min
  7. SLAs & support agreements Service level agreements, uptime guarantees and credits, and support and maintenance terms — read from both the buyer's and the seller's side. intermediate 9 min
  8. NDAs & the rest of the landscape NDAs, master service agreements, acceptable-use policies, and beta/evaluation agreements — the remaining agreements software businesses run on. beginner 9 min

Module 7 — Choosing Your License & Agreements

Everything applied: a repeatable framework that turns your goals into a license choice, a step-by-step walkthrough to pick yours, a way to determine which other agreements your software needs, and a full worked example end to end.

  1. A framework for choosing A repeatable decision framework — goals, business model, dependencies, and risk tolerance map to a license and a set of agreements, not the other way around. intermediate 10 min
  2. Choosing your license, step by step A guided walkthrough to land on your license — open source, proprietary, source-available, or dual — with the questions that decide each fork. intermediate 10 min
  3. Which agreements does your software need? Determining the full set — EULA or ToS, privacy policy, DPA, SLA — from how your software is delivered, who uses it, and what data it touches. intermediate 10 min
  4. Putting it all together An end-to-end worked example — choosing a license and the full agreement set for a GopherTrunk-like product — plus where to go next and how to stay compliant. advanced 11 min
  1. Glossary of software-licensing terms Plain-language definitions for every term in the path — copyright, copyleft, permissive, GPL/AGPL/LGPL, dual licensing, EULA, ToS, SLA, DPA, SBOM, SPDX, indemnity, and more — cross-linked to the lessons.