How to Start an Open-Source Project

• 

  Kim Harrison
  

How to Start an Open-Source Project

Why is Heavybit posting a first-principles guide on how to create an open-source project? While the open-source space is arguably becoming more fraught with tensions between startups, foundations, and massive vendors over misaligned incentives and commercial pressure, it’s still a positive force for software development, and still a viable way to create and distribute software.

Open-source software (OSS) is computer software with source code that is made available to the public for use, modification, and distribution. Because of this, anyone can view, change, and redistribute the software's code. This allows developers to study, customize, and improve it.

Open-source software is often developed by a community of programmers who collaborate to improve the software. It can be released under different licenses, including the ‘restrictive’ GNU General Public License (GPL) or the ‘permissive’ MIT License, which define the terms under which the software can be used, modified, and distributed.

There are OSS operating systems, web browsers, programming languages, databases, web servers, and cloud platforms. Examples include: Linux, Android, Firefox, Python, Java, MySQL, Ruby, and Kubernetes.

There are many advantages to using open-source software products. It is often free or at a low cost. It can be customized to meet specific needs. Open source encourages innovation and collaboration through larger community involvement. Users can inspect code to scout out vulnerabilities, which arguably makes open-source community involvement an extremely fast method to identify and fix security issues.

This in-depth guide will cover the fundamentals of how to create an OSS project, including:

• Should You Launch Your Own Open Source Project? -
• How to Start an Open Source Project
• Building Open Source vs. Closed Source Software
• Additional Considerations When Building an OSS Project

More Open-Source Resources:

• Article: How to Think About Positioning in Open Source with Emily Omier
• Article: Understanding Business Models & Defensibility with Adam Jacob
• Article: The Power User's Guide to Open-Source Licenses
• Article: How to Successfully Fork an Open-Source Project
• Article: What Success Looks Like for Modern Open-Source Software Startups
• Article: Understanding Legal Issues for Open Source Software Start-ups
• Video Archive: DevGuild Open Source Covers GTM, Security, Licensing, and More

Should You Launch Your Own Open Source Project?

Before starting (or contributing to) an OSS project, it's important to consider your motivations. Publishing an OSS project means you are sharing your work publicly, and this could be beneficial for a variety of reasons:

• Share Knowledge: Do you have a solution to a common problem that others could benefit from? Contributing to open-source projects can be incredibly rewarding, knowing that your work is helping others.
• Learn and Improve: Working on an open-source project allows you to practice and improve your coding skills, problem-solving abilities, and collaboration techniques.
• Innovation: By sharing your code, you can foster innovation and collaboration, leading to new ideas and solutions.
• Build a Community: Are you passionate about bringing like-minded individuals together? You can connect with other developers, learn from their experiences, and contribute to a larger open-source community.
• Gain Visibility: Open-source projects can build your reputation in the tech community.

If your motivations align, then you should also consider other implications of being involved with an OSS project.

Do you have a unique or valuable idea? Make sure your project isn't solving a problem that is already addressed. It’s a good idea to make a quick trip to GitHub to find similar projects, trending or otherwise, with similar keywords–as well as to find any potential templates that can get your started faster. Furthermore, make sure you have a clear idea of the problem you want to solve or the feature you want to implement.

Are you ready for the commitment? Running an open-source project requires ongoing effort that’s easy to underestimate if it’s your first time. You’ll need to fix bugs, update dependencies, and address issues. You will be responsible for managing the community, including responding to feedback, moderating discussions, and guiding new contributors who may have very different perspectives and a very different coding style.

And then there's project documentation--you'll need to provide clear, comprehensive documentation (ideally with no typos) so that community members can easily adopt and provide meaningful contributions, such as tagging good first issues for first-timers to make their first contribution. Ideally, your docs include a beginner’s guide, guidance on how to report issues for bug fixes, and coding standards to keep contributions consistent.

Do you have the necessary skills and resources to maintain it? You should have a solid understanding of the technologies and tools involved. Good communication skills are also critical--you'll need to provide good documentation and effective communication with your community, which may need to evolve into a complex ecosystem of end-users, open-source contributors, commercial partners, and nonprofit foundations.

It's important to consider if you have the bandwidth to take this on if you want your project to be successful long-term.

Are you prepared for the risks? Exposing your code to the public can increase the risk of security vulnerabilities. Furthermore, once your project is open-source, others can fork it, potentially competing with your original version. On a personal note, not all feedback will be constructive--be prepared for critique to be a part of the regular workflow.

Also, the pressure to maintain and grow the project can become overwhelming, so be careful to protect yourself (and your team) from burnout.

Do you understand open-source licensing? You need to be aware of licensing and copyright considerations. Choosing the right license is critical. There are permissive licenses that allow others to use, modify, and distribute your code with few restrictions. There are also copyleft licenses that require derivatives to remain open source, and there are repercussions for making sudden "rug pull" license changes midstream.

Be sure you understand the implications of your choice before getting started. Finally, you need to ensure all dependencies and libraries used in your project comply with open-source standards and licensing.

Launching your own open-source project can be incredibly rewarding, but it requires careful planning, dedication, and a willingness to adapt. If you're confident in your idea and prepared for the challenges, it might be time to take the plunge. If not, consider contributing to existing open-source projects to build experience and connections before launching your own project.

How to Start an Open Source Project

So you’ve decided that you want to make your project public and publish it as open source. Here’s a guide on how to get started. While you might already have your MVP, be sure to start at the beginning and confirm you do in fact have a clear sense of direction and…

1) Define your vision and goals.

Clearly articulate the problem your software solves. Is there a tool or software that you've wished existed? Are there recurring issues or challenges in your field that could be addressed with a new tool? Are there any gaps in the market? As you define your project, be sure to research existing solutions to determine if you should create something new or contribute to an existing project.

Also, outline what you hope publishing this project will achieve. This can include goals around adoption, open-source contributions, or community growth.

2) Define the project scope.

It's beneficial to start small and focus on solving a specific problem effectively. Outline the core functionality of your project. Determine the minimum viable product or smallest set of features that will make your project useful. Then outline the long-term vision, including the project's future direction and potential growth–which should inform your overall roadmap.

3) Choose an open-source license.

There are permissive licenses (e.g. MIT or Apache 2.0) which allow broad usage and modifications with minimal restrictions, and copyleft licenses (e.g. GPL) that require derivatives to remain open-source. Each license has specific terms regarding usage, modification, and distribution. Check out tools like Choose a License that can provide guidance, or Heavybit’s own power user’s guide to open-source licenses. And if necessary, consult with a lawyer to ensure you're choosing the right license for your project. Once you've selected a license, don't forget to include it in the root directory of your project.

4) Start coding and set up a repo.

As you prepare your codebase, be mindful to write clean code and keep files organized. This will make it easier for community members to understand what you've created and provide feedback and/or contributions. Remember to remove sensitive information, such as secrets, API keys, or private data.

5) Write documentation.

Write a clear and concise README file explaining the project's name and purpose, installation instructions, and usage examples. (Over time, there may be a need to expand your docs with more-extensive tutorials and guides.) Include the chosen license file in your repository.

Also include a CONTRIBUTING file that provides clear instructions for contribution guidelines on reporting issues, suggesting new features, and submitting pull requests. And make sure to also write a Code of Conduct that defines expected behavior and moderation policies to create an inclusive community.

6) Set up version control and hosting.

Use Git to track changes and collaborate with others. Choose a hosting platform--popular options include GitHub, GitLab, or Bitbucket. Upload your codebase and documentation to the platform.

7) Build an open-source community.

As mentioned, be sure to include clear docs to make contributing to and utilizing your project a beginner-friendly experience. It’s important that contributors understand your project and how they can provide feedback and contributions. Use an issue tracker to let contributors easily submit bug reports, feature requests, and discussions. Categorize issues with labels.

Use communication channels such as Slack, Discord, mailing lists, and/or discussion forums to share notifications on important milestones or alerts. Be sure to respond to feedback, issues, and pull requests promptly. Externally, participate in relevant forums, social media groups, and online communities. Depending on where your target audience congregates, you may find yourself on BlueSky, LinkedIn, Reddit, or elsewhere.

8) Release your project.

Decide on a release schedule, whether it's frequent small releases or larger, less frequent releases. Use Git tags to mark specific releases. Share your project on social media, relevant websites, and forums. Add your project to open-source directories like Open Source Collective or Awesome Lists.

9) Maintain your project.

Now that you have an open-source community rallying around your project, it's important to sustain it and encourage it to evolve. Pay attention to user feedback and suggestions. Respond to pull requests and provide feedback. Continuously improve your project based on user needs and evolving technologies. Regularly communicate updates, milestones, and plans. And ensure instructions and examples reflect the current state of the project.

Building Open Source vs. Closed Source Software

Open source and proprietary each offer unique advantages for software founders. However, open source is a unique space that requires investing in very deliberate decisions and activities, like community building, license management, and having to dual-track free-to-use projects and for-pay commercial products or services. Open source is not a “business model,” nor is it an easy track to pivot your company towards or away from.

Let’s begin with key milestones for software startups that founders should be aware of, including:

Important Milestones for Proprietary Software Startups

• Product Validation: Before launching your startup, it’s crucial to understand your prospective customers’ pain and whether and how your product idea will solve it
• Foundational Messaging: It’s also critical to build out a messaging house that will inform how you pitch your product to buyers and your company to new hires
• Building a Minimum Viable Product: After finding the person whose pain you solve and learning how to speak to them, you need a viable prototype that offers value for money
• Launch: At some point, your startup needs to announce some level of product availability for your prospective audience

Potential OSS First Steps: Existing Foundation, Net-New, or Existing Project

Open-source startups may need to take additional steps, depending on the state of their project and who owns it. If you don’t own, and don’t plan to own, something already owned by other individual project maintainers or a foundation, but believe you can build and provide a distinctly different offering, you may need to create a fork of that project. If you’re creating a net-new project, you’ll need to hit a different set of milestones.

Important Milestones for OSS Startups

• License Selection: As mentioned, you’ll need to select an appropriate license that allows you enough flexibility to achieve your goals
• Prepare an Initial, Community-Ready Release: You’ll need code that contributors and users can begin using, adding to, and on which they can provide feedback
• Create Community Documentation: To drive adoption, you’ll need to create community-ready documentation and a README file
• Set Up a Publicly Accessible Repository: You will, of course, need to make your code available through a public repo on GitHub or another community space
• Create a Community Meeting Place: You’ll need an online destination, such as an online forum or chat, for your community to congregate

Building a Bridge to Open-Source Business Models

Founding an open-source startup can be challenging as it requires a great deal of up-front work–such as building a community and creating docs–that doesn’t generate revenue. While it’s possible to create a thriving open-source company, it’s important to zero in on how you plan to sell something that customers will eventually pay for.

Some examples of business models for open-source startups include:

• Pro-Serv: For-pay professional services to guide customers using open-source projects. Examples: Red Hat (services for Linux) and Canonical (services for Ubuntu)
• Open Core/Freemium: For-pay software features that complement the open-source project. Examples: GitLab and H2O.ai (which both offer premium enterprise editions)
• SaaS: Annual software-as-a-service subscription model. Examples: GitHub (including security and storage features) and Databricks (including pay-as-you-go usage)
• Charitable Donations: And some open-source orgs rely on charitable donations. Examples: Wikimedia, Mozilla Foundation

Additional Considerations When Building an OSS Project

Some other important considerations to be aware of include:

• How to Price and Package Multi-Tier Products: Open-core products can be challenging to price so that they provide sufficient value, while not cannibalizing the open-source project
• Juggling Multiple Codebases: Open-core startups will also need to manage both the open-source codebase and the premium codebase and keep them at parity
• Community Management: OSS projects live and die by their communities–keeping them vibrant and engaged with dedicated comms is critical