Bryntum Gantt vs DHTMLX Gantt

If you're choosing between Bryntum Gantt and DHTMLX Gantt, you're deciding how much project scheduling logic your application should get from the Gantt component itself. Both libraries support dependencies, drag-and-drop editing, and large datasets. Bryntum Gantt includes auto-scheduling, critical path analysis, client-side export, and AI support in the base product.

Start with these questions:

• How much scheduling logic should the Gantt library handle?
• How does the license cost scale across the team?
• Does the team need documentation tooling for AI coding agents?

This comparison uses these criteria:

• Installation and setup
• Licensing and cost
• Scheduling features
• Export and project file support
• Framework and TypeScript support
• AI support

Bryntum Gantt vs DHTMLX Gantt: scheduling features and license structure

The table below covers the criteria most relevant to a production integration decision.

Feature	Bryntum Gantt	DHTMLX Gantt
License	Commercial	GPL (Standard) / Commercial (Pro)
Free tier	Trial only	GPL Standard edition
Auto-scheduling	✔️	Pro only
Critical path	✔️	Pro only
Resource management	✔️	Pro only
Baselines	✔️	Pro only
Drag-and-drop editing	✔️	✔️
Task splitting	✔️	Pro only
Undo / redo	✔️	✔️
React / Angular / Vue wrappers	✔️	✔️
TypeScript	✔️	✔️
Export to PDF / Excel	✔️ (client-side)	Online export; local module by license/add-on
MS Project import / export	✔️	Online service or local module
Primavera P6 interop	Import only	Online service or local module
Multiple instances per page	✔️	Commercial license or higher
MCP server	✔️	✔️
Claude Code skill	✔️	❌
Built-in AI assistant	Experimental feature	❌

Bryntum Gantt

Bryntum Gantt is a commercial JavaScript component for building project management interfaces. It is built on ChronoGraph, an open-source reactive scheduling engine: task dates recalculate automatically when predecessors change, calendars skip non-working time, and constraints interact the way they do in Microsoft Project.

The left panel is built on Bryntum Grid, giving it full sorting, filtering, grouping, and column configuration without extra setup.

Installing Bryntum Gantt

The trial package is available on the public npm registry without authentication:

npm install @bryntum/gantt@npm:@bryntum/gantt-trial@7.2.4

This minimal responsive setup shows a two-task project with a dependency. The container height drives the Gantt height via CSS, with no pixel values hardcoded in the component config:

<!-- index.html -->
<style>
  html, body { margin: 0; height: 100%; }
  #container { height: 100vh; }
</style>
<div id="container"></div>

import '@bryntum/gantt/fontawesome/css/fontawesome.css';
import '@bryntum/gantt/fontawesome/css/solid.css';
import '@bryntum/gantt/gantt.css';
import '@bryntum/gantt/svalbard-light.css';
import { Gantt } from '@bryntum/gantt';

new Gantt({
  appendTo : 'container',

  columns : [
    { type : 'name',        width : 250 },
    { type : 'duration',    width : 80  },
    { type : 'percentdone', width : 60  }
  ],

  project : {
    startDate : '2025-01-14',
    tasks : [
        {
            id : 1000, name : 'Launch SaaS Product', expanded : true, percentDone : 35.7,
            children : [
                { id : 11, name : 'Install Apache',      startDate : '2025-01-14', duration : 3, percentDone : 50 },
                { id : 12, name : 'Configure firewall', startDate : '2025-01-14', duration : 3, percentDone : 50 },
                { id : 15, name : 'Run tests',          startDate : '2025-01-21', duration : 2, percentDone : 0 }
            ]
        }
    ],
    dependencies : [
        { fromTask : 11, toTask : 15, lag : 2 },
        { fromTask : 12, toTask : 15 }
    ]
  }
});

Three CSS imports are required in order: FontAwesome icons, the structural gantt.css, and the theme file. Swapping svalbard-light.css for svalbard-dark.css changes the full visual appearance at import time. DomHelper.setTheme() handles runtime theme switching.

ChronoGraph scheduling engine: auto-scheduling, critical path, and client-side export

The ChronoGraph scheduling engine is the main differentiator. Auto-scheduling, dependencies, constraints, project calendars, task calendars, and resource calendars work together through the project scheduling engine. ChronoGraph is open-source under the MIT license, so the reactive scheduling logic is auditable.

The export pipeline covers PDF, PNG, Excel, ICS, and MS Project XML without a server round-trip, all client-side. Bryntum also imports MS Project and Primavera P6 files through MPXJ. The theming system ships ten themes across five light/dark pairs, all switchable at runtime.

Bryntum Gantt: bundle size, trial watermark, and config structure

The trial watermark persists during evaluation, which complicates early stakeholder demos. The API surface is large: project-level and Gantt-level configuration are separate objects with different responsibilities. The uncompressed bundle reaches 4 MB or more, which is a meaningful consideration for applications where initial load time is critical.

Bryntum Gantt pricing: perpetual license from $940 per developer

Per-developer licensing starts at $940. A three-person team pays $2,820 as an entry cost. OEM licensing for SaaS products, where the Gantt is embedded in software shipped to end users, requires a separate quote. All licenses are perpetual and include 12 months of updates.

TypeScript, framework wrappers, and the project-vs-inline-data rule

TypeScript type definitions ship with the package, covering the full Gantt and project API. Documentation at bryntum.com includes live code examples with an in-browser editor.

Framework wrappers for React (@bryntum/gantt-react), Angular, and Vue 3 are published on the same version cycle as the core.

One rule to encode early: never mix the project prop with inline data props (tasks, dependencies, resources). Using both throws at runtime. Pass all data through project, or use the inline props directly with no project key.

For runtime theme switching, load theme files with <link> tags marked for Bryntum theme detection and call DomHelper.setTheme(). Static themes can still be bundled in the normal build.

Coding agent support: MCP server, Claude Code skill, and AI assistant

Bryntum ships two complementary AI tools: the MCP server exposes documentation retrieval, and the Claude Code skill adds judgment.

The MCP server (mcp.bryntum.com) exposes a search_bryntum_docs tool that returns version-specific documentation, source code examples, and configuration options for Gantt, Scheduler, Calendar, Grid, Task Board, and Scheduler Pro. The command to register it in Claude Code:

claude mcp add --transport http bryntum https://mcp.bryntum.com

The Claude Code skill guides agents through common mistakes: CSS import order, mixing project config with inline data props, and the correct dark mode pattern via DomHelper.setTheme(). An agent with both the MCP server and the skill produces working Bryntum code with fewer correction cycles than with documentation retrieval alone. This combination of structured retrieval plus agent-level judgment is unusual among JavaScript Gantt libraries.

Bryntum also ships an experimental AI chat panel (available on Gantt, Scheduler, and Calendar) that connects to Anthropic, OpenAI, or Google models. End users give natural language instructions such as "move all tasks assigned to Alex to next week" without touching the interface directly.

Use Bryntum Gantt when scheduling correctness is a hard requirement

Bryntum Gantt is the right call when scheduling correctness is a hard requirement: auto-scheduling, critical path analysis, resource calendars, and MS Project interop. The AI tooling, with both an MCP server and a dedicated Claude Code skill, gives it a meaningful edge for teams using AI coding agents.

DHTMLX Gantt

DHTMLX Gantt is a mature JavaScript Gantt library in active development since 2009. The Standard edition is GPL-licensed, free for compatible open-source projects. Paid licenses include Pro features:

• Auto-scheduling
• Critical path
• Resource management
• Baselines
• Task splitting

Export is available through the DHTMLX online service, with watermark rules and local module availability depending on license/support status.

Bryntum Gantt is more predictable for production scheduling because auto-scheduling, calendars, critical path, and client-side export sit in the product, while DHTMLX Gantt is cheaper to enter but requires teams to plan around Pro features, online export, and license boundaries.

The library uses a global gantt singleton: configuration is set on the global object before gantt.init() is called. The pattern is well-documented, but running two independent instances on the same page requires the Commercial license tier.

Installing DHTMLX Gantt

The package is on the public npm registry:

npm install dhtmlx-gantt@9.1.4

This minimal responsive setup fills the container via CSS. Configuration goes before gantt.init(), and data loads after:

<!-- index.html -->
<style>
  html, body { margin: 0; height: 100%; }
  #container { width: 100%; height: 100vh; }
</style>
<div id="container"></div>

import { gantt } from 'dhtmlx-gantt';
import 'dhtmlx-gantt/codebase/dhtmlxgantt.css';

gantt.config.date_format = '%Y-%m-%d';
gantt.config.columns = [
  { name : 'text',     label : 'Task', tree : true, width : 250 },
  { name : 'duration', label : 'Days', align : 'center', width : 80 },
  { name : 'progress', label : '%',    align : 'center', width : 60,
    template : task => Math.round((task.progress || 0) * 100) + '%' }
];

gantt.ext.zoom.init({
  levels : [
    { name : 'month', scale_height : 50, min_column_width : 120,
      scales : [{ unit : 'month', format : '%F %Y' }] },
    { name : 'week',  scale_height : 50, min_column_width : 60,
      scales : [{ unit : 'month', format : '%F %Y' }, { unit : 'week', format : 'W%W' }] }
  ]
});
gantt.ext.zoom.setLevel('week');

gantt.init('container');

gantt.parse({
  data : [
    { id : 1, text : 'Phase 1: Discovery', start_date : '2026-05-01', duration : 14, open : true },
    { id : 2, text : 'Requirements',       start_date : '2026-05-01', duration : 5, parent : 1, progress : 1   },
    { id : 3, text : 'Design',             start_date : '2026-05-08', duration : 8, parent : 1, progress : 0.2 }
  ],
  links : [
    { id : 1, source : 2, target : 3, type : '0' }
  ]
});

Free GPL Standard edition and lower entry price than Bryntum

The DHTMLX GPL Standard edition is a free option for open-source projects, and commercial licenses are perpetual with no annual subscription. For teams that need only the Gantt component, the entry price is lower than Bryntum.

Both Standard and paid editions can use the DHTMLX online export service for formats such as PDF, PNG, Excel, iCal, MS Project, and Primavera P6. Task splitting, which divides a task bar into non-contiguous segments, is Pro-only.

Auto-scheduling, critical path, and resource management are all Pro-only

These features are all Pro-only:

• Auto-scheduling
• Critical path
• Resource management
• Baselines
• Task splitting

Most production applications need at least two of them, which means the Standard edition works well for basic open-source Gantt use cases but is a weak stand-in for evaluating a production project management tool.

Online export sends data to the DHTMLX-hosted export service rather than processing entirely in the browser. GPL output contains a DHTMLX watermark; paid licenses remove the watermark during the valid support period. Local export modules are separate deployable services and are included or sold separately depending on license tier.

The global singleton is the most consequential architectural constraint. Running two independent Gantt instances on the same page requires a Commercial license upgrade, which complicates multi-panel dashboards. Unit testing is also harder because state persists between tests unless explicitly reset.

DHTMLX Gantt pricing: free GPL, from $699 for paid licenses

The Standard (GPL) edition is free for compatible open-source projects. Paid licenses are perpetual with no annual subscription:

• Individual: $699
• Commercial: $1,399
• Enterprise: $2,999
• Ultimate: $5,999

Local export module availability depends on the license. The MS Project local export module is listed as a $350 add-on.

Global singleton initialization, TypeScript, and framework wrappers

TypeScript type definitions are included in the package.

The global singleton has specific initialization requirements: set configuration properties on gantt.config before calling gantt.init(), then load data via gantt.parse() after init. Keeping that order avoids stale global state and setup that is hard to reason about in tests.

Framework wrappers cover React, Angular, and Vue. Documentation is at dhtmlx.com with code examples, though the interactive editor is less extensive than Bryntum's.

MCP server with RAG-based docs, no Claude Code skill

DHTMLX ships an MCP server that covers the full product line: Gantt, Scheduler, Suite, Kanban, Diagram, Spreadsheet, and more. It uses RAG over current documentation, so responses reflect the latest API rather than LLM training data. The command to register it in Claude Code:

claude mcp add --transport http dhtmlx-mcp https://docs.dhtmlx.com/mcp

DHTMLX has no dedicated Claude Code skill and no built-in AI assistant for end users.

The global singleton is the main friction point for AI agents beyond documentation retrieval. An agent may generate code that works for a single instance but fails when the application mounts a second Gantt view, because the singleton state carries over between instances. Without a skill to encode this constraint, agents repeat the mistake.

Use DHTMLX Gantt when budget outweighs license gates

The global singleton and the Pro-only gate on core scheduling features are the two constraints to evaluate first. For teams where budget is the deciding factor and the application does not require multiple independent Gantt instances, DHTMLX Pro is a viable option. Pro licensing from the start is the right approach: the Standard edition feature gaps surface quickly in production.

Which is better: Bryntum Gantt or DHTMLX Gantt?

For most production applications, Bryntum Gantt is the better choice. Auto-scheduling, critical path analysis, resource calendars, and MS Project export work out of the box. Multiple Gantt instances on the same page are supported without a license upgrade. The MCP server and Claude Code skill make Bryntum easier to use in teams that rely on AI coding agents.

Bryntum Gantt gives teams a simpler feature boundary, while DHTMLX Gantt Pro is reasonable only when budget is the hard constraint and the application does not require multiple independent Gantt instances on the same page. Pro licensing is necessary from the start for production scheduling features.

For open-source projects that need a basic Gantt without scheduling logic, the DHTMLX GPL Standard edition is free with no evaluation watermark.