[opensourcedex]

Kaneo is a free, open source project & work management project written in TypeScript and released under MIT. It has 9,107 GitHub stars, 794 forks and 70 open issues, and was last pushed 5 hours ago. On this registry it ranks #10 of 62 tracked projects in Project & Work Management, with 5 head-to-head comparisons available. It gained 52 stars over the last 6 tracked days.

What is Kaneo?

What it is

Kaneo is an open source project management tool for development teams, published under the MIT license and written in TypeScript. It describes itself as "all you need, nothing you don't," and its README frames the design goal around restraint: the project's authors argue that the problem with most project management platforms is not a lack of features but an excess of them, where notifications, unnecessary buttons and complex workflows pull teams away from building products. Kaneo belongs to the self-hosted project and work management ecosystem, and its topic list places it explicitly alongside issue trackers and kanban boards, naming Jira and Linear as the commercial products it positions itself against.

The concrete problem it solves is the trade-off teams usually face between capability and overhead. Kaneo offers issue management and kanban-style project tracking, but keeps the surface small so that the tool stays out of the way of an existing workflow rather than forcing the team to adapt to it. Because it is self-hosted, the data stays under the operator's control, and the underlying stack combines Hono and React with TypeScript throughout. The project also carries an MCP topic, and it is distributed as a Docker image as well as through a hosted cloud option on kaneo.app.

Key capabilities

  • Issue management and issue tracking, as described in the repository topic list.
  • Kanban-style project and work management boards.
  • Self-hosted deployment, so project data remains on infrastructure the operator controls.
  • TypeScript codebase built on Hono for the API and React for the client.
  • MCP integration surface, listed among the repository topics.
  • Permissive MIT license, allowing commercial and internal use without copyleft obligations.
  • Container image published at ghcr.io/usekaneo/kaneo:latest for direct Docker deployment.

Who uses it and how

  • Development teams wanting an issue tracker without the workflow configuration burden of larger platforms.
  • Teams standardising on a Docker Compose deployment with a bundled PostgreSQL 16 database.
  • Organisations deploying via Coolify, using the shipped compose.coolify.yml build pack with domain assignment and auto-generated secrets.
  • Operators wanting a single-command install, using the drim CLI, which provisions automatic HTTPS, database setup and service configuration.
  • Teams avoiding hosted SaaS entirely by running the stack on their own servers.

Getting started

Install through the drim CLI with curl -fsSL https://assets.kaneo.app/install.sh | sh followed by drim setup, or run the published Docker image alongside PostgreSQL 16 using the provided Docker Compose file, copying .env.sample to .env and setting POSTGRES_PASSWORD and AUTH_SECRET. A hosted cloud option and Coolify deployment path are also documented.

When to use it — and when not to

Kaneo is a reasonable choice for teams replacing Jira or Linear who value a smaller feature surface and self-hosted data over deep configurability and the integrations those paid products accumulate. A self-hoster must operate the components themselves, including a PostgreSQL database, the environment variables such as KANEO_CLIENT_URL, AUTH_SECRET and `DATABASE

project readme (upstream, from github) — read inline

Kaneo's logo

license GitHub Workflow Status Discord Sponsors

Quick Start | Website | Cloud | Discord

Kaneo Dashboard

Why Kaneo?

After years of using bloated, overcomplicated project management platforms that distracted from actual work, we built Kaneo to be different.

The problem with most tools isn't that they lack features, it's that they have too many. Every notification, every unnecessary button, every complex workflow pulls your team away from what matters: building great products.

We believe the best tools are invisible. They should amplify your team's natural workflow, not force you to adapt to theirs. Kaneo is built on the principle that less is more: every feature exists because it solves a real problem, not because it looks impressive in a demo.

What makes it different:

  • Clean interface that focuses on your work, not the tool
  • Self-hosted so your data stays yours
  • Actually fast because we care about performance
  • Open source with a permissive MIT license

Learn more about Kaneo's features and capabilities in our documentation.

Sponsors

Kaneo is open source. If you find it useful, consider sponsoring the project to help support ongoing development.

Getting Started

One-Click Deployment with drim

For straightforward deployments, use drim - a CLI tool that handles everything for you:

curl -fsSL https://assets.kaneo.app/install.sh | sh
drim setup

That's it. Your Kaneo instance will be running with automatic HTTPS, database setup, and all services configured.

Perfect for quick deployments and production setups where you want things to just work.

Quick Start with Docker Compose

The fastest way to try Kaneo is with Docker Compose. This sets up Kaneo and PostgreSQL with a single Kaneo container:

services:
  postgres:
    image: postgres:16-alpine
    env_file:
      - .env
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U kaneo -d kaneo"]
      interval: 10s
      timeout: 5s
      retries: 5

  kaneo:
    image: ghcr.io/usekaneo/kaneo:latest
    ports:
      - "5173:5173"
    env_file:
      - .env
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

volumes:
  postgres_data:

Save this as compose.yml, copy .env.sample to .env, uncomment KANEO_CLIENT_URL=http://localhost:5173, and set POSTGRES_PASSWORD= and AUTH_SECRET=, run docker compose up -d, and open http://localhost:5173.

In Docker Compose, the bundled Kaneo container reaches PostgreSQL at the service hostname postgres. If you run the API on your host instead of inside Compose, use localhost or set DATABASE_URL explicitly.

Important: See our full documentation for detailed setup instructions, environment variable configuration, and troubleshooting guides.

Deploy on Coolify

Kaneo ships a Coolify-optimized compose.coolify.yml. In Coolify, create a Public Repository resource pointing to https://github.com/usekaneo/kaneo, pick the Docker Compose build pack (Base Directory /, Compose Location compose.coolify.yml), assign a domain to the kaneo service as https://your-domain.com:5173, set KANEO_CLIENT_URL, and deploy. AUTH_SECRET and the database password are auto-generated by Coolify. Leave KANEO_API_URL unset (it is derived from KANEO_CLIENT_URL; a localhost value breaks the browser API calls). See the Coolify deployment guide for details.

Development Setup

For development, see our Environment Setup Guide for detailed instructions on configuring environment variables and troubleshooting common issues like CORS problems.

Configuration

Kaneo requires several environment variables to be configured. The Docker Compose setup above handles the database automatically, but you'll need to configure environment variables for the API and web services.

For complete configuration instructions, including all required environment variables, database setup for non-Docker deployments, and advanced settings, see the documentation. Advanced deployments can still use the separate ghcr.io/usekaneo/api and ghcr.io/usekaneo/web images.

Kubernetes Deployment

If you're running Kubernetes, we provide a comprehensive Helm chart. Check out the Helm chart documentation for detailed installation instructions, production configuration examples, TLS setup, and more.

Development

Want to hack on Kaneo? See our Environment Setup Guide for detailed instructions on configuring environment variables and troubleshooting common issues like CORS problems.

Quick start:

# Clone and install dependencies
git clone https://github.com/usekaneo/kaneo.git
cd kaneo
pnpm install

# Create a .env file in the root with required environment variables
# See ENVIRONMENT_SETUP.md for detailed instructions

# Start development servers
pnpm dev

For contributing guidelines, code structure, and development best practices, check out our contributing guide and documentation.

MCP Server

Kaneo has an official MCP (Model Context Protocol) server, so AI tools like Claude, Cursor, and other MCP clients can manage your tasks, projects, and labels. Every instance ships a built-in HTTP MCP endpoint at /api/mcp, and for stdio clients there is the official @kaneo/mcp package on npm (npx -y @kaneo/mcp).

Community

Contributing

We're always looking for help, whether that's:

  • Reporting bugs or suggesting features
  • Improving documentation
  • Contributing code
  • Helping other users on Discord

Check out CONTRIBUTING.md for the details on how to get involved.

License

MIT License - see LICENSE for details.

Repobeats analytics image

Built with ❤️ by the Kaneo team and contributors

Frequently asked questions

Is Kaneo free to use?

Kaneo is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Kaneo do?

Simple, secure project management for development teams

What is Kaneo written in?

Kaneo is primarily written in TypeScript. Its source is publicly available at https://github.com/usekaneo/kaneo, and it has 9,107 GitHub stars.