I just posted to Quora in response to:
If I study at a university and I create software in my own time, does the university own the licensing to my software?
There’s no good general answer, since things vary by country and university and circumstance. Working on your “own time” does not matter if you were otherwise hired to work on the software for a university project. Same deal if you work on your “own time” but use university information or computing resources not otherwise made generally available to students. And “own time” doesn’t matter if your university has a grasping IP policy that insists that the university has a claim to ownership for anything you do under the “auspices” of the university, “related to” work being done at the university, or some such broad scope. If you have a real concern, you may need to talk to an attorney about the specifics of your situation. But here are some things that might help you navigate the situation.
Let’s talk United States, because that’s what I know.
First, other than in very particular situations, if you don’t sign a written instrument assigning your software to the university, the university doesn’t own your software. General rule: no siggy, no university ownership. That’s because in the U.S., the default is that inventors own their inventions and authors own their works of authorship, including software code treated as a “literary” work. (If you are working for the university, and the software is within the scope of your employment, then the code is work made for hire and the university is the author, and thus the owner, of copyright; if you were hired to invent or assigned to conduct research by the university, then the university may have equitable title to any inventions embodied by your code—but that wasn’t your premise—your premise was that you study at a university, not work for it as a programmer or inventor).
If anyone else wants to own your software (under whatever theory of ownership), they have to get an assignment or get a court to rule that you as inventor or author are obligated to assign. If a university wants to own, then it will have to persuade you or compel you to assign that ownership, or persuade a court to compel you to assign.
[Caveat: ownership of inventions is weird–it’s common law, not in patent law. So states can pass laws that preempt common law on ownership of inventions. Some states have passed laws purporting to limit employer claims on inventions but which turn out to preempt common law and give employers a broader basis for making claims than they would have under common law. A state such as Ohio, for instance, has a law that claims university ownership of inventions–very broadly–made at state universities. Public university lawyers have argued in court that their policy documents have the force of law, and so when a public university claims broad ownership, it’s not a matter of contract (unless the university is fool enough to go out of its way to make it appear that it is) but rather of a weird assertion of administrative law. Federal copyright law is different. 17 USC 201(a) provides that copyright vests in the author, and that preempts common law and states’ opportunity fiddle with it.]
Now, before we get into what you can do to prevent a dispute with your university over ownership, you have to realize that university ownership is not necessarily a bad thing. Depending on how your software is going to be developed and managed and supported going forward, university ownership might be a very good thing—or at least a decent alternative among a bunch of mostly bad realistic alternatives. For instance, if you want your software broadly used in a research community, ownership by a recognized research university might be way more effective in promoting adoption than if you, clutching your pearly code, market the code yourself. If you want to get your code acquired by a company, you may find that university ownership is a plus rather than a downside. Getting code to any company under license for development and commercial sales can be a pain, and just because it’s a pain when a university is involved does not mean it wouldn’t also be a pain for you if you tried to do the deal on your own.
Furthermore, ownership is not necessarily the most important thing. There are typically five elements to consider: ownership, control, money, attribution, and liability. If your software is released under the GPL, say, then it doesn’t so much matter who owns—you and anyone else has access to the source code—free speech, not free beer—to do what you want with it. Let the university distribute under the GPL, then, and make your money (if money is your thing) selling your services working with the code. Liability tends to follow ownership, so if your software does anything mission critical, anything involving health, anything where something or someone could be damaged by relying on your code, then you might really, really want someone else to own the code and with that ownership take any liability. A deep pocket. A lightening rod. Bless that university for wanting to step in front of the arrow meant for you. So choose which elements matter to you and keep your focus there.
But here, you’ve chosen to focus on ownership. Let’s stay with that. Let’s say that you want to avoid a university claim of ownership. Start with university IP policy. There are usually three policies—one for patents (inventions, really) and one for copyright and one for research data. There’s also often a policy on academic freedom, but no one bothers with that anymore.
Software often is claimed by the invention policy, even though software’s core IP position is generally copyright plus trade secret (to the extent that you have not made public your source code) and perhaps a trademark in a distinctive name. University invention policies have gone bonkers as administrators and their lawyer friends try to bake in the broadest definition of invention they can. So you will see invention policies that define invention as anything patentable or not patentable. What is a non-patentable invention? Well, it’s *anything* that a university administrator calls an invention. These invention policies also include random laundry lists of invention-things: know-how, data, improvements, technology, software. You could write a code to track your fingernail growth over time and it would be within the scope of many university invention policies.
University copyright policies follow a different line of development and often start with a general statement that authors own their works unless there are special circumstances (such as work assigned by the university). This approach follows the idea that universities value academic freedom—faculty and students (and even sometimes staff) should have the right to decide what and when and where to publish. Often, a university will have a policy (often in the faculty handbook) that asserts that freedoms of research and publication are fundamental to the university—and that’s every bit as much part of university IP policy as anything in an invention or copyright policy, though try pointing that out to a university IP attorney.
Oddly, university copyright policies tend to define their scope in terms of copyrights. They don’t go out of their way, say, to distinguish original works of authorship from unoriginal works (there’s usually a different policy for that, having to do with using copyright works without permission). Nor do copyright policies generally expand their definition of “work” to include data or know-how or technical information.
Instead, under the influence of the administrative folks all grasping to have the university own inventions (and non-inventions), copyright policies have been changed to distinguish between “traditional scholarly works” and other works. This is a mind-numbing distinction. An article prepared for a journal might then be a “traditional scholarly work” but software written to illustrate an algorithm described in that article might be considered “non-traditional.” Again, it is often up to an administrator to decide what is traditional and what isn’t. Such policies, then, provide no way for new works of authorship—digital media, software, email, database compilations, apps, macros, scripts—to ever become “traditional.” Thus, your software might fall outside of “traditional” and be exposed to a university claim.
But there’s hope. Copyright policies often distinguish student work and disclaim ownership of anything students prepare for course work. There’s some logic to that—including, oddly, federal law that requires a student’s permission before a university may release any educational record—and that might well include software if written for a class (and therefore, say, graded). But there’s also despair. In conflicts between invention and copyright policies, university invention policies typically claim precedence. Thus, if a university administrator calls your software an “invention,” then invention policy will be applied and copyright policy mostly ignored.
Third, there’s also usually a data policy. The typical data policy will assert that the university owns data, including records of research. Since software is necessarily also a “record” of its own development, it is easy enough for software to come under a university data policy. Luckily, most data policies are restricted to research data and there often the focus is compliance with regulatory and contractual data retention requirements, so if your software is not tied to a research activity and doesn’t use university data for its operation, then you may be okay here.
But—keep in mind that from a university administrator’s point of view, it’s not whether you are working on a university research project but whether your software has any relationship to *any* research project at the university, including all the ones you aren’t working on. In one situation, a student attended a public lecture by a faculty member, got an idea and went off to write some code—it’s just that his code was remarkably like the code that the faculty member also had written. From a copyright perspective, there’s no infringement because the student had no access to the faculty member’s code, but from an “invention” point of view, the student is rather hosed because the faculty member had priority for the inventive bit. If your software uses university data—scrapes data from a university web site, or takes data presented in class, or uses data provided by a friend working in a university research project, then the university may well make an ownership claim based on data.
Now, for a really obscure bit—but significant. Universities get lots of software and code development tools on “educational” licenses. There may be deep discounts for these licenses, but those discounts come with “educational use only” restrictions. Similarly, U.S. copyright allows for “fair use” of works, including for teaching, scholarship, and research. To top it off, public universities, as instruments of state government, cannot be sued for infringement in federal court as a matter of sovereign immunity under the 11th amendment. Thus, university treatment of copyright tends to be less diligent than it otherwise would be. If you, a student, use the university’s code development tools, or a programming environment provided by the university (even for class), you may well run afoul of “educational use only” restrictions or other copyright claims of third parties. You might own your code, but you might not have the right (control) to distribute that code or use it in any context other than for education. If your code is directed at educational uses, even that might not save you, depending on what your university has agreed to. A university may even waive its fair use rights to get an educational license.
Even with all this burden of policy, keep in mind that university administrators often don’t follow policy the way it is written. Some portions of policy they ignore, other parts they interpret in crazy ways (that they don’t think are crazy at all), and other parts they waive when they want to. And if you disagree, then keep in mind that university policies provide an appeals process—under which the university decides. Until that appeals process is done, you will have a tough time getting to court to blow your hundred thousand dollars trying to get clear title to your code. And if you do anything with your code before that process is done, the *university could sue you*. Welcome to the machine.
Keep in mind that most student written code a university doesn’t care about. I wrote tons of codes as an undergraduate and a graduate student—at home and at the university and as part of jobs at the university or tested or demonstrated at the university, and as part of my coursework and dissertation work. No one at the university bothered with that code. Heck, when I became the director for software licensing, I didn’t bother with that code or much anything else that a student wrote, unless the student was hired to write code or was working on a faculty-led research project. I even had a situation in which a student was working on a research project, got an idea for a code approach, was told that that code approach was absolutely not part of the project, wrote the code on the side, and then gosh the faculty project director decided that the code *was* worthwhile after all. I refused to claim the code for the university—the faculty director had clearly rejected the code idea and that rejection controlled.
So, what can you do?
First, try to get a confirmation upfront from a university representative that the software you intend to write, if you think it will be important, will not be subject to a claim by the university. On your own time, with your own resources, not connected to anything at the university, not using the university’s name, data, code, whatever. That university representative might be in the IP (licensing/tech transfer) office or might be a faculty advisor or instructor—but define the project as best you can, and put it in writing and ask for a written confirmation. If the code is part of a class project, then make that clear. (If other students will work on the code, then there’s a whole different set of issues involving group ownership—and if anyone working on the code is a university staff programmer or otherwise hired to code or to assist (like a teaching assistant), then the university may have a work-for-hire claim to the code as a co-owner). IP is an onion. The more you peel back layers, the more you cry.
You may not get a university confirmation, and even if you do it will come with all sorts of qualifications and handwaving about not applying if you stray outside your scope or end up using university resources anyway. At least you have put the university on notice and they haven’t stopped you, so there’s a bit of a defense available for you later.
Second, consider releasing your code open source, especially GPL. If you go this route, once the source is out there, it will be difficult for the university to claw it back. If you are not revealing trade secrets of the university or violating some university educational license for code or information, then the university generally won’t bother with you. If they think that you have invented something, however, and think that they could get a patent on something your code does, then they might pursue that angle, even if you have released under the GPL—they haven’t.
Don’t accept any university claim that “federal law” requires them to take ownership. That isn’t true. Even under Bayh-Dole, universities have no obligation to take ownership (and no special right to claim ownership). Same for “university policy.” University policies might claim ownership but never require the university to take ownership—there’s almost always a step by which the university can waive its policy claim or assign back if for some reason your code is a “work-made-for-hire.” But university administrators are prone to waive policy only with strings attached, like demanding a royalty-free license for university use or if assigned back, expecting a royalty-bearing license if you ever sell your code. I know, it’s a piss. But that’s what university IP is these days.
Third, if you want to own your code, then don’t code at the university, don’t look at university code (unless it has been released under an open source license—GPL, BSD, MIT, Apache are commonly used), and don’t bring your code into the university to demonstrate or test. Don’t name your software something associated with the university. Don’t use the sports mascot or the university’s name or abbreviations. Don’t use a university address for contact information. Keep records of your work to show where and when you have worked. If you get work at the university—even in the cafeteria or library—then as part of accepting that offer get a written confirmation that your software project will not be subject to any claim by the university.
If you do want the university to own your code, then reverse all this—code at the university, get into a research environment if you can—volunteer!—and test all you can at the university. The administrative sharks will sense there’s something in the water and will ask for a “disclosure” and you are home free from there to get the university to own the code and then try to “commercialize” it. Could be useful if the people involved know what they are doing. But—good sign they do—is that they *won’t* ask for assignment, *won’t* think to commercialize your code, *won’t* deal with you even if your code is *really, really, really* cool stuff. That’s right—the folks that know the most about code in a university won’t demand to own your stuff. You would have to win them over with a deal that made sense—and generally that deal would have some clear public purpose, not simply to make money selling software. So, research tool, or public app, or industry standard.
Talk to folks at your university before you start coding, if there’s any chance an administrator could make a claim. Get something in writing if you can. Keep records of your work. Don’t use university resources, avoid anything that’s educational licensed. Don’t rely on “fair use.” Check the licensing for code libraries before you incorporate them. If you bumble into creating code without doing any of this, to get any confirmation from the university that it doesn’t have a claim, you will have to disclose everything. And you will need a lawyer.
Hope this helps.