Every now and then I've been ranting here that there's a missing task management product for software teams: one that would embrace that tasks form DAGs, not flat two-level trees, and one that would have GANTT charts built-in. This seems to tick both of these boxes, and couple more as well.

Thank you for submitting it. You may have just found exactly what I was looking for.

ClickUp and Jira both fit your description.

The problem with software for software teams is not that the big players are missing features. It's that every team wants something that is highly customized for them, and that leads to feature bloat.

Then people say, "Why doesn't Jira have ____?" In fact it does have that, but it's hard to find it in the massive UI that contains all those features.

I had this same issue testing Asana many years ago. I could tell that it could do what we wanted (or what anyone wanted), but I didn't want to spend 3 hours figuring out how to do it.

Haven't heard of ClickUp before. Perhaps I instinctively ignored it before because of the name. It looks like a crossbreed between Airtable and Jira, and it makes me wonder how well it'll handle dense task lists... Still, thanks for mentioning it, I'll take a closer look.

RE Jira - I've never seen a GANTT chart & critical path pulled out of it, though I imagine management 2 layers above me had that option. That said, my experience with Jira was somewhat painful, with a rather slow and annoyingly click-heavy UI. Also, IIRC, tasks in Jira can only have one level of subtasks, and I don't recall being able to form DAGs from them.

I imagine it's hard to prevent featuritis in this tool category, when you're addressing different hierarchy levels simultaneously. That said, there are many successful companies, like Trello, that thrive on delivering bare-bones, simplified tooling with perfected UX. I just wonder why there doesn't seem to be anything like that for a featureset that includes tasks forming DAGs, GANTT charts, computing critical path, and relative scheduling (e.g. "task Y takes starts after X and takes 5 work days").

EDIT: OmniPlan, not OmniProject, and I promised a footnote ;)

JIRA is as system that is hilariously hobbled by two forces - JIRA admins and management, the latter often driving JIRA admins into making bad changes[1].

It has a very keyboard-capable UI that isn't highlighted enough (make it exempt from anything that might hijack keyboard, and hit . (dot) - it will bring you an autocompleting text box allowing you to do every action you can on given page).

The big issue however is that there's nothing really integrating the links system between JIRA items, and the basic task model is indeed rather limited. The links are fully free form (which can be a pain when someone defines a new copy of every standard link type, in german, without connection to localization system), but I have yet to see something that isn't the advanced query (i.e. the SQL-like queries you can type in various places in JIRA) that exposes it nicely and graphically.

That said, graph-based task representation is the norm on the higher end of _desktop_ project management tools, ones that often involve physical things to make, like MS Project or OmniPlan (and going back all the way to LisaProject, which apparently became very liked at NASA for exactly that graph based view).

[1] At one point, a friend of mine had enough and implemented exactly what the management asked for, without spending futile time trying to help them see the truth, or fixing it quietly by themselves. The results were glorious, as the whole project essentially ground to halt for a sprint or two, and could be a poster example of why people tell you to not mess and use provided standard workflows. Management never again asked for workflow changes after asking for reversal of their own design[2].

[2] Management, in their infinite wisdom, designed a one-way-only workflow, where a task could proceed a workflow a bit like this: Backlog -> TODO -> Development -> QA -> Done. Notice lack of any way to move a stage back, and there was no way to force change a task to different stage. Tracking real status of tasks became impossible as everything was left at "Development" because if you found anything to fix after it left QA... well, no way to change the state without hacking the database, which might have not gone well with Atlassian Cloud admins ;)

Thanks for the explanation!

> and hit . (dot) - it will bring you an autocompleting text box allowing you to do every action you can on given page

How I wish I knew that at my {previous}^2-job, where we were heavy JIRA users. I remember getting so angry off at the frontend performance that I actually (somehow) got minimal API access and ended up timesheeting from a Lisp REPL.

I thought about my previous comment through the night and realized that, at some point, I should have had found a reference manual for JIRA and read it end-to-end (reading manuals cover-to-cover is a superpower, but that realization only truly hit me around the end of said job). Also, I now know enough to articulate what was my biggest discomfort with JIRA (beyond abysmal performance): lack of clear mental model of what it does, and what is being represented inside. This came about not just because the product is large, but also because JIRA admins - we (developers) had access restricted only to a tiny portion of the product, so I couldn't just poke around (my usual way of grokking software) and build a clear mental picture. Next time in such situation, I'll just go straight into "read docs cover to cover" mode.

> That said, graph-based task representation is the norm on the higher end of _desktop_ project management tools, ones that often involve physical things to make, like MS Project or OmniPlan (and going back all the way to LisaProject, which apparently became very liked at NASA for exactly that graph based view).

I suspected so! I saw some of these capabilities during my brief exposure to the "corporate pointy-haired MBA" project management tools during my time at the university. But I get the feeling that it's another place where Agile culture is throwing the baby out with the bathwater.

JIRA becomes a lot simpler (in the same way Lisp is simpler, not user-friendly UI) when operated from issue search with JQL filters and heavy use of the keyboard ops.

You can then make a mental model that ultimately JIRA has project, which have a "table" of issues/items, with various attributes each - plus simple workflow engine - everything else is just built around it, whether kanban boards, SCRUM, various reporting tools (very powerful), or random plugins (integration with SCM, time tracking, etc. etc)

There is a decent GANTT plug-in for Jira called WBS Gantt. I am not affiliated with them, but I've used it successfully. https://marketplace.atlassian.com/apps/1211768/wbs-gantt-cha....

We tried ClickUp and gave up quickly. It has so many features that finding the thing to do takes a lot of time.

Using ClickUp heavily for my content business... but definitely not for software! ClickUp has a huge range of features and it's getting more and more complex to onboard people.

Really cannot wait for Google Workspace to offer real task/project management features.

How does ClickUp embrace the DAG model?

I've built a visual project plan tool to scratch this itch for myself - www.gameplan.global

It's not open source though

It's a visual DAG that auto schedules out the plan given the constraints. It's not for everybody - but for highly visual people it seems to resonate really strongly.

Wow, this looks slick, I'll give it a go! On a glance, it seems to check the important boxes for me. Thanks for making it!

Thank you for building this!

You're very welcome!

If you have any questions please email me on phil@gameplan.global

I use it all the time, I looove it for early project scoping.

It has a lot of stuff I've been looking for as well, but it's still missing one important (IMHO) view - the graph/network view, like this: https://imgur.com/a/KrWqYGS (hopefully the link works).

This is taken from an old project proposal of mine, done in OmniPlan 3, and shows causal dependencies between components more than time-based scheduling (like in GANTT chart)

> Every now and then I've been ranting here that there's a missing task management product for software teams: one that would embrace that tasks form DAGs, not flat two-level trees

MS Project and many other task tools recognize that, considering all of start-to-start, start-to-finish, finish-to-finish, and finish-to-start dependencies (all of which can be simultaneous as well as happen-first dependencies), tasks can form directed graphs (not restricted to acyclic).

And many of those tools also have GANTT charts built in.

I see several people have posed about OpenProject on HN, but never before made it to the front page. Good to see it up there now.

Very similar to what I suddenly realised I want (for personal use) over the weekend: DAG with task nodes and dependency edges, priorities assigned to nodes, and the answer to the question 'what is first on the critical path to the highest priority task'.

Could you elaborate on it? It sounds a lot like the MS Project/Omniplan way. Do you/How do you integrate with the code development workflow and version control?

I don't have it, I was just thinking about what my ideal 'to do list' type app might look like.

For personal use, as in general tasks not necessarily code for any particular project, so I haven't really envisioned any such integration.

I just get bogged down/stressed thinking of numerous things I want/need to do, there's some interdependence, a few may occur to me at a time or be particularly weighing on me on any given day, and I'd like a way to graph the dependence, actually view it as a graph, annotate some tasks with their priorities (but not all, some might be 'don't care'), and then find out which is the next thing I need to do.

Since the next thing isn't necessarily the highest priority thing, as annotated (or stressed about), it's the first thing on the path (dependency chain) to the highest priority thing. Attempting to see that clearly as a mental picture is what causes me most stress, I think.

Would this help? No weights, but DAG, graph view, Gantt, and malleability. https://github.com/andrey-utkin/taskdb/wiki/Live-demo

Redmine?

No limit on task nesting, gantt charts built in, git integration, and very customizable.

Upvoted, but also noting OpenProject is a Redmine fork

oh, i didn't notice that.

I'll just say that redmine DB schema is pretty simple, and metabase works well with it if you need more complicated reports :)

What happens to project planning when tasks and dependents form cycles? Doesn't that happen pretty often?

If you have a cyclic dependency in your project then you more likely have a DAG that’s not sufficiently broken down. That is if A and B seem to depend on each other you have some sub tasks in each that need to be pulled out. If this still fails to break the apparent cycle, you’ve got a problem.

Another thing to keep in mind is that there's a distinction between a system having cyclic dependencies (I need A & B working because they communicate with each other), and the task ordering. During development you can end up with a partially correct system. If A sends to B, and B sends to A but I only have one person working on both parts, then it's possible I'll end up in a state where A sends to B but not the reverse. That's fine during development. Yes, the system is "wrong" per the design or spec. But it's a partial system (like a half-built bridge). Your tasks will appear to have a cycle, but in reality you will break it by selecting one portion to complete first so in the end it remains (based on the chosen path) a DAG.

> That is if A and B seem to depend on each other you have some sub tasks in each that need to be pulled out.

That produces subtasks without cycles, giving you a way forward.

Assuming you still want to maintain shared information about the tasks which contain subtasks, those tasks still have a dependency cycle between them though, which is correct because tasks are often like that - they need to move forward together.

I assume a decent plan willbe hard to make without understanding that a sizeable portion will have to be reworked. (In software at least). For example, the Boehm model. How do you make a Gantt chart without abstracting away the whole project?

There shouldn't be any cycles in properly broken out plan, because the flow of time creates a causal directness; a true cycle would prevent any of the tasks involved from starting, which obviously doesn't happen in real life. Sometimes you may need to break things down a bit more.

And that's why I'm asking for a tool that lets me model projects as Directed Acyclic Graphs of tasks. Because all I seem to be getting in popular tools is a flat list with some categorizing, or a single level of subtasks at best. I want to be able to express directly that this subtask has sub-subtasks, and that this sub-subtask depends on completion of a subtask from some other task (without making it a dependency between root tasks).

> There shouldn't be any cycles in properly broken out plan, because the flow of time creates a causal directness

Real dependencies can be not-before rather than strictly-after, which admits cycles without any problems with the flow of time.

Then I'm fine with a cyclic graph.

Cool discussion. Thanks all.

maybe you can split the task into its subtasks and forget about the task itself. Then you forget about the concept of subtasks and you are left with a bunch of tasks. now you can define dependencies between these tasks like you would normaly do.

Their website certainly doesn't make it easy to locate the source code (https://github.com/opf/openproject) or make it clear what license it's under (GPLv3). I had to navigate all the way to the manual installation guide to find a link to the GitHub.

It also isn't readily clear what the feature difference is between the community and enterprise editions. A feature matrix would be welcome here.

It does look like a really useful piece of software though.

I found it on https://www.openproject.org/pricing/ under Feature Comparison

Wow that's actually an impressively detailed breakdown that managed to address every single question I had. (I feel dumb for not checking "pricing" before, but seriously why wasn't that under "features"?)

Core maintainer here, I agree that this should be more discoverable. I will forward this to include a comparison link on the feature page itself.

I honestly think it is discoverable enough. I assume the reason why it is slightly complicated to find is business related. And that is understandable and fine.

With Amazon taking any opensource and hosting it on its own I would even go as far as saying use less permissive licence for future releases. Openproject came a long way.

There, I said it.

The source code is linked in the footer, you just need to click the unlabeled github icon.

My company is evaluating Open Project, among other solutions. We're outgrowing our current system, and also beginning to suspect the developers aren't interested in moving it forward, or even properly maintaining it. We like that Open Project is open source. We think building as much as possible on open source will, in the long term, be a win. We also have a lot of Ruby knowledge in house, so we could contribute to it ourselves.

What has everybody's experience been?

> beginning to suspect the developers aren't interested in moving it forward, or even properly maintaining it

This will be true of all systems. Devs hate adding comments, writing documentation, maintaining tasks/wikis/etc., and everything else that we need them to do. Some people try to make them track their time, which I think is both pointless and unlikely to happen.

The only solution to this is to move it out of the "discipline" column and into the "process" column. For example, I set up git hooks so that a commit will be rejected unless it's tagged with an issue number. And then I have another rule that says that issues aren't accepted unless they have the important fields filled out ("steps to reproduce" for a bug, "user story" for a feature).

It's not perfect, but it definitely creates better habits overall.

Core maintainer of OpenProject here. We do welcome all outside contributions, but please note that while the application relies heavily on Ruby/Rails for backend, API and rendering, a large portion is also Angular/Typescript.

This will sometimes make it harder for developers to start working with OpenProject since for many topics, you will need both (e.g., API changes and frontend work). Especially so since the application has evolved for more than 10 years.

We recently did work on a "big picture" documentation for new developers to understand some of the concepts at play: https://docs.openproject.org/development/concepts/

I wasn't clear. I'm describing the developers of the project management system we now use. They announced new scheduling features over a year ago, and nothing has happened. And there have been a lot of slowdowns and crashes, which they have been slow to fix.

Our developers like tools that support their processes. They just want something that works, and is under active development.

I'd suggest you also consider ProjeQtor. It's astonishingly feature rich and at the same time, very lightweight resource-wise (PHP + MySQL and you are good to go).

https://www.projeqtor.org/en/

It is missing a resource management module. This is a huge omission. Other than that it's decent.

Core contributor of OpenProject Here, this ist an Epic that ist high up in the roadmap but due to its complexity has been pushed out the past two releases.

This is something where we know it's painfully missing and is being planned and actively worked on.

If it's not a secret, which system do you currently use?

My company is looking to replace JIRA. We use Kanban. Has anyone had experience with this or other products that you'd recommend for a Kanban workflow?

Wekan is a pretty full featured and FOSS kanban project. The maintainer is very active and there's a good amount of community-submitted improvements.

We use https://www.taiga.io/

You can combine Kanban with scrum if needed.

Edit: and here is the link (https://tree.taiga.io/support/) that gives more information about taiga. It is not apparent from their website that you can host it yourself for free.

look into gitlab, it's become pretty fully featured recently

We have completely replaced a set of jira tools with gitlab. Its great.

I use kanboard. It's much simpler than JIRA, but for pure Kanban it's great. It's open source and you can self host it: https://kanboard.org/ (not affiliated - just a satisfied user)

Trello[1]?

[1]: https://trello.com

I think people are skeptical of atlassian after their cloud migration announcement

Planner in MS Office

It is basic, but has an API and a sort of automation scripting engine and is fully integrated into Teams.

Haven't heard of that but looks very useful and integrated into everything else they do.

If you have office 365 its worth looking at because its included with the subscription. They are going through some internal changes on the planner product, as they are sort of merging it with their "TODO." app with it also.

I'm currently moving my Trello/Kanban stuff in Gitlab. Seems to be going OK so far. And I can make easy add-on via API

Used Trello but it's a bit pricey when it comes to using all of the features. Currently using Restyaboard, which is the free version of Trello, with a Kanban board, Gantt chart, reminders, priorities...etc.

https://kantree.io (they have private-cloud and on-premise options: https://kantree.io/enterprise)

If you have some time check out our app at https://www.paymoapp.com - it's quite versatile (has boards and gantt)

So this is Open Source but there are "premium features". How does that work license-wise?

It's only partly open sourced, the premium features are closed (open-core in other words). Also, Open Project is a fork of Redmine. I evaluated both a while ago, and Open Project differs in two ways: fancier design and a broader scope. While redmine is geared towards software development, Open Project has generalized the interface, language and some features to be better suited for any business out of the box. Redmine, on the other hand, has a lot of plugins that is not compatible with open project and can be customized to suit your needs.

Great product. I think I used it back in 2005 for the first time.I'm glad to see it has been modernized with agile artifacts. Cool.

Not to be confused with Project Open

http://www.project-open.com/

Does this have auto scheduling of tasks? (I could not determine from the features page).

Looks like it’s the same documentation system as the one used by GitLab.

agile boards not included in community edition makes it hard to consider switch from self hosted gitlab :(

Hi, ProjeQtOr ticks all the boxes. It integrates all the features that others have, and even more. Two level WBS : of course, ProjeQtOr does it, and even 20 or mode Levels if you wish !!! You don't have restrictions with ProjeQtOr; You can have projets with sub-projects, with sub-sub-projects (and so on) and each project can have tasks, with sub-tasks, and sub-sub-tasks (and so on). But if you want only two levels, you also can. Gantt chart ; ProjeQtOr also provides it but not only; You can have project portfolio, resource Gantt chart (not a real Gantt but very easy to read and very efficient to analyse resource planning). ProjeQtOr also provides real capacity planning calculation : you don't only draw a gantt chart, ProjeQtOr calculates it for you depending on the constraints and resources capacity (when resources are shared on several projects, it's not an easy trick). ProjeQtOr also calculates the critical path (which is in fact a critical chain in ProjeQtOr as planning is driven from resource capacity) And all of this is easy to install, easy to use, and free.

Really, ProjeQtOr is worth a try.