Open Source Jira Alternatives

Run several coding agents and each ends up in its own terminal tab, forgetting context between sessions and demanding the same explanation four times a day. Multica puts those agents and the people they work with on one board, where an agent takes an issue, works it, comments as it goes and hands the result back for review.

Multica ships no model of its own. It drives agent CLIs already installed on a machine you control, 26 of them including Claude Code, Codex, Cursor, Copilot, Kimi and OpenCode, and the runtime is a daemon on your laptop or cloud box, so code never leaves it.

The workspace is built around the handoff and everything that follows it.

• Agents as teammates: each gets a name, a provider and a runtime, then appears on the board.
• Squads and skills: people and agents share a team, and solved problems become reusable playbooks.
• Execution log: every tool call, command and error replays with timestamps and token cost.
• Review gates: work lands in review rather than main, so a human decides what ships.
• Autopilots: standups, audits and reports run on a cron with nobody left to remind.

Self-hosting runs through Docker Compose or Helm, Git integration covers GitHub, GitLab, Gitea and Forgejo including self-hosted instances, and access scopes control which agents each member may run.

Plane tracks issues, runs cycles and manages product roadmaps without the tool itself turning into the project. It is aimed at teams who want the tracker under their own control rather than behind another hosted subscription.

Self-hosting goes through Docker Compose or Kubernetes, with deployment guides for each, and instance administrators configure the whole installation from an admin mode the project calls God mode. A free cloud account exists for anyone who would rather skip infrastructure entirely.

The product is organized around a small set of concepts.

• Work items: tasks written in a rich text editor with file uploads, sub-properties and references.
• Cycles: time-boxed pushes tracked with burn-down charts so momentum stays visible.
• Modules: large projects split into smaller pieces that can be managed on their own.
• Views: saved and shareable filters showing only the issues relevant to someone.
• Pages: notes with AI assistance and rich text that convert into actionable items.

Analytics sit on top of all of it, giving real-time insight across the data already in the system so blockers surface early. The stack is Django on the backend with Node and React Router on the frontend, and the team collects suggestions through a public forum and GitHub issues.

The Huly Platform is a framework for building business applications, and the repository already ships several of them, namely Chat, Project Management, CRM, HRM and an applicant tracking system. Other teams build products on top of the same platform, including Huly itself and TraceX.

One status note matters before adopting it. The hosted Huly service is being discontinued because its hosting is no longer funded, with shutdown expected on July 20, and existing users are asked to export their data and move to a self-hosted setup or another hosted option. Self-hosted deployments are not affected.

Reading the repository is easier with a few of its conventions in mind.

• Self-hosting: A separate huly-selfhost project brings the platform up with Docker for people who only want to run it.
• Version tags: Tags starting with v are production releases, while s tags are pre-release builds unsuited to production.
• Branches: Contributions target develop, staging carries pre-release testing, and main drives production deployments.
• API client: A typed client covers platform operations for integrations, with a separate repository of usage examples.
• Build setup: Development needs Docker, the repository Node version and a GitHub token with read access to packages.

An architecture overview and a changelog sit alongside the code, and a backup and restore guide walks through exporting data and bringing it up elsewhere. The platform suits teams willing to run and update it themselves.

GitLab manages Git repositories with fine-grained access controls and adds the machinery around them, merge requests for code review, continuous integration and delivery pipelines that build, test and deploy applications, and an issue tracker, issue board and wiki for every project. More than 100,000 organizations use it, most of them on servers they run themselves.

A note on where the code lives. This GitHub repository is a mirror, while all development takes place on GitLab.com. A separate read-only mirror carries the build without proprietary code, and neither mirror accepts issues or merge requests.

The project ships in editions with different terms attached.

• Community Edition: Available freely under the MIT Expat license.
• Enterprise Edition: Adds features aimed at organizations past a hundred users, with official support for subscribers.
• JiHu Edition: A variant tailored specifically for the Chinese market.
• Open core: Most code is MIT, while files under the ee directory are proprietary yet source available and open to contributions.
• Hosted: GitLab.com runs the same product as a service, with a free trial of the Ultimate tier.

Installation is recommended through Omnibus packages, a Debian or RPM download installed with the system package manager, which beats compiling from source. GitLab is a Ruby on Rails application running on Ubuntu, Debian, CentOS, RHEL or OpenSUSE with Ruby 3.3, Git 2.33 or later, Redis 6 and PostgreSQL 16.5.

Classic, agile and hybrid work all fit inside OpenProject, web-based project management for teams and organizations that require transparency, flexibility and data sovereignty. Projects, portfolios, products, tasks, bugs, roadmaps and team collaboration live in one platform rather than in a separate subscription for each of them.

It is aimed at organizations wanting an open source, enterprise-ready alternative to Jira, MS Project, Monday, Asana and YouTrack while keeping full control of their data and infrastructure. The project reports use by enterprises, public institutions and highly regulated industries.

The platform stretches across several ways of running work.

• Agile and classic planning: boards for Kanban, Scrum and SAFe alongside Gantt charts for scheduling.
• Portfolio management: project and portfolio views, extended to product and release planning.
• Time and cost: time tracking, cost reporting and budgeting attached to the work itself.
• Collaboration: wikis, forums, news, and meeting agendas with their minutes.
• Integrations: Nextcloud, XWiki, GitHub and GitLab among others.

The Community Edition is free of charge and self-hosted, with in-depth installation guides for production use, while an Enterprise Edition adds support and further add-ons in the cloud or on premises. Security issues are handled through private disclosure so users have time to upgrade, and the code is licensed under GPL version 3.

Kaneo was written in reaction to project management platforms that pull attention away from the work. Its argument is that most tools fail by having too many features rather than too few, so every notification and button has to earn its place.

The application runs as a single container beside PostgreSQL, which keeps deployment close to trivial. Images are published to a container registry, and a Compose file with a handful of environment variables is the whole setup.

Several deployment routes are documented for teams with different appetites for configuration.

• One-command install: a CLI called drim sets up HTTPS, the database, and every service in a single step.
• Docker Compose: the bundled container plus PostgreSQL, configured through an env file.
• Coolify: a dedicated compose file, with the auth secret and database password generated for you.
• Kubernetes: a Helm chart covers cluster installs, production configuration, and TLS setup.
• Split images: advanced setups can still run separate API and web images.

Configuration comes down to a client URL, an auth secret, and a database password, and the documentation covers the CORS and hostname mistakes that trip up first installs. Kaneo is MIT licensed and self-hosted, so project data stays on the team's own infrastructure, and a hosted version exists for anyone who would rather not run it.

Fizzy is the kanban tracking tool for issues and ideas built by 37signals, and this repository holds its source code. Running it yourself puts the board where your team files bugs and half formed ideas on infrastructure you control.

The project assumes you are willing to operate your own instance. You bring a server, pick one of two deployment routes and set the configuration options that customize the installation. Everything else is documented in the repository rather than sold as a service.

Each route has its own guide, and the choice comes down to whether you plan to touch the code.

• Docker image: pre-built, for a server you already run and code you do not intend to change.
• Kamal deployment: the recommended route when you modify Fizzy and push your own build to a server.
• Configuration options: the settings that customize an installation, covered in both deployment guides.
• Development guide: local setup for anyone who wants to work on the code before deploying it.
• Style guide: the conventions a contribution is expected to follow before it is submitted.

Modifying Fizzy to your liking is encouraged rather than merely tolerated, and contributions come back as pull requests once you have read the style guide. Fizzy is released under the O'Saasy License, so read those terms before building anything commercial on top of it.

Redmine is a flexible project management web application that can be self-hosted. A team that wants issue tracking, a wiki, time tracking and a repository browser normally assembles three or four hosted services and pays for each. Redmine puts them in one Rails application running on your own server.

Everything is scoped by project, and projects nest into subprojects. A project can be public or private, permissions are granted through roles rather than to individual people, and workflow transitions are configurable by role and issue type. Custom fields extend issues, time entries, projects and users when the built-in shape does not fit.

The application covers what most teams reach for.

• Issue tracking: a flexible tracker with customizable statuses and issue types.
• Gantt chart and calendar: both generated automatically from issue dates.
• Time tracking: entries reported by user, type, category or activity.
• Repository browser and diff viewer: works across Subversion, CVS, Mercurial, Bazaar and Git.
• Wiki, forums, news and files: kept per project, written in textile syntax.
• Feeds and email notifications: activity and changes pushed out of the app.

Authentication supports multiple LDAP servers and user self-registration with three activation methods. Redmine is cross-platform and cross-database, running on MySQL, PostgreSQL or SQLite, and the interface is translated into forty-nine languages. It is released under version 2 of the GNU General Public License, with the documentation kept in the repository's doc directory and on the project's own site.

Taiga is a project management tool for cross-functional teams that want to run Scrum or Kanban without a training program first. This repository holds taiga-back, the server that stores projects and exposes the REST API every Taiga client talks to.

The project keeps three documentation hubs, one for the API, one for installing Taiga on your own server, and a community site that doubles as the support desk. Bug reports go to Taiga's own issue tracker, which the team prefers over GitHub issues, and a separate address exists for security reports.

The product itself, as described on the Taiga website, covers the ceremonies an agile team actually runs.

• Kanban: boards with swimlanes, WIP limits, zoom levels, extensive filters, and a user story archive.
• Scrum: backlog and sprint planning with epics and sub-tasks, estimation per role, and burndown charts at project and sprint level.
• Issues: integrated tracking with custom types, priorities, and severities, plus a way to promote an issue into a user story.
• Reporting: team performance dashboards, a full project timeline, personal notifications, and a wiki.
• Self-hosting: on-premise installs keep all data on your own servers, with more than twenty translations available.

Switching a project between Kanban and Scrum works in both directions, so the method can change without moving tools. Every accepted patch is licensed under MPL 2.0, and the contribution policy asks you to keep it that way.

Most teams pay for a project tracker and a customer feedback tool, retype the same updates into both, and still leave users guessing. Sayr collapses that into one board with two views: the team sees every task, and the public sees only what has been marked public.

The stack is TanStack Start with React, TanStack Router and TanStack Query on the front end, a Hono API on Bun serving REST and WebSocket traffic, Drizzle ORM over PostgreSQL, Redis for the job queue, MinIO for uploads, and Nginx routing each organization to its own subdomain.

Visibility is the idea the rest of the product hangs on.

• Per-item toggles: tasks, comments, labels and timeline entries each carry a public or private setting that applies immediately.
• Public portal: visitors vote on tasks, submit new ones from templates and comment, with a member badge marking official replies.
• GitHub sync: issues and tasks stay in step per repository, and commit or pull request keywords such as Fixes and Closes land on the task timeline.
• Account security: two-factor codes, passkeys through WebAuthn and per-session revocation ship with the app.
• REST API: bearer tokens, an OpenAPI spec and rate limits of 100 requests a minute for authenticated callers.

Community Edition self-hosts a single organization with unlimited members and publishes Docker images that are edition locked at build time, alongside a hosted plan and a licensed enterprise edition listed as coming soon. Running it yourself needs Bun 1.2, Node.js 22, pnpm 10.6, PostgreSQL 15 and Redis for the queue.

Task management gets stripped back to the essentials here. Mimrai tracks tasks and projects, and its maintainers position it as an early, lightweight alternative to Jira, Asana, Linear and Monday.com. They call the project a first stage of development shaped by feedback, though the repository is now archived.

The codebase is a Turborepo monorepo written in TypeScript and running on Bun. React and Next.js drive the interface, Supabase backs the data layer, and Tailwind CSS with Shadcn UI supplies the styling and components.

Hosting is split across three services.

• Supabase: database, storage and realtime updates.
• Vercel: the marketing website and the dashboard.
• Fly.io: the API.

Around that core sit the pieces that keep it running day to day. Trigger.dev handles background jobs, Resend delivers email, GitHub Actions runs continuous integration, Upstash provides Redis caching, Sentry captures errors, OpenPanel records events and analytics, and OpenAI powers the AI features.

Licensing follows two paths. Non commercial use falls under AGPL-3.0, and by using the software you accept those terms. For commercial use, or a deployment that needs a setup fee arrangement, the founders ask you to contact them directly for a commercial license instead.