Syncfusion Gantt alternatives

Syncfusion Gantt is a JavaScript Gantt library with a Community License that is free for qualifying organizations: under $1 million in annual revenue, five or fewer developers, and ten or fewer total employees. If you're looking for an alternative, you're likely outside those limits, want published paid pricing, or need an HTTP MCP server for AI-assisted development rather than Syncfusion's stdio-based server.

What to know about Syncfusion Gantt alternatives

The table below compares licensing, scheduling features, framework support, package access, and MCP support.

Feature	DHTMLX Gantt	ScheduleJS	Netronic VSW SE	Bryntum Gantt
License	GPL (Standard) / Commercial	Commercial (from 1,500 EUR)	Commercial (quote-based)	Commercial
Free tier	GPL Standard	None	None	Trial only
Auto-scheduling	Pro only	❌	❌	✔️
Critical path	Pro only	❌	❌	✔️
Resource management	Pro only	✔️ (rows)	✔️	✔️
Framework support	React, Angular, Vue, Svelte	Angular only	Framework-agnostic	React, Angular, Vue, plain JavaScript
Public npm	✔️	❌	❌	Trial packages and wrappers
Agent support (MCP, skills)	HTTP MCP server	❌	❌	HTTP MCP server, Claude Code skill

DHTMLX Gantt

DHTMLX Gantt is a JavaScript Gantt library with a GPL-licensed Standard edition covering drag-and-drop, dependency links, and basic task rendering. Paid licenses (Individual through Ultimate) unlock Pro features:

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

The library uses a global gantt singleton: configuration goes on the global object before gantt.init() runs, and data loads via gantt.parse() after init.

Installing DHTMLX Gantt

The package is on the public npm registry:

npm install dhtmlx-gantt@9.1.4

This minimal setup shows a two-task project with a dependency:

<!-- 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' }
  ]
});

Two setup details require attention:

• The default date format is DD-MM-YYYY. Using ISO strings requires setting gantt.config.date_format = '%Y-%m-%d'.
• gantt.init() must come before gantt.parse(). Reversing the order is a common setup mistake.

DHTMLX Standard edition is free for GPL-compatible open-source projects

The GPL Standard edition is free for compatible open-source projects with no time limit and no per-developer fee. Paid licenses are perpetual with no annual subscription.

DHTMLX publishes paid license prices directly. After the Community License window closes for a growing team, DHTMLX gives clearer paid pricing than Syncfusion because it does not require a sales quote. It is the only option in this comparison with an open-source tier that carries no revenue or headcount eligibility requirement.

Auto-scheduling, critical path, and resource management require the DHTMLX Pro upgrade

These features are all Pro-only:

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

Multiple independent Gantt instances on the same page require the Commercial license at $1,399.

Online export sends data to a DHTMLX-hosted service. GPL output includes a watermark. Local PDF or PNG export is a $350 add-on for Individual licenses and included with Commercial and higher. DHTMLX Gantt Standard, ScheduleJS, and Netronic VSW SE omit auto-scheduling and critical path, while Bryntum Gantt includes both in the base license.

DHTMLX Gantt pricing: $699 to $5,999, perpetual licenses

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

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

ScheduleJS

ScheduleJS is a commercial Angular Gantt library that renders to an HTML Canvas element rather than DOM elements. It suits applications that need smooth scrolling at very large row counts. The library handles rendering and interaction but leaves scheduling logic, auto-scheduling, critical path, and export to the application.

Installing ScheduleJS

ScheduleJS is not on the public npm registry. After purchasing a license from AISO SA and receiving the package, place it in a local_modules/ folder in the project root and install it as a local file reference:

yarn add file:./local_modules/schedule

ScheduleJS targets Angular. A new Angular project provides the required shell:

ng new project-name --style=scss

The following shows a team sprint Gantt with two members. Setup spans three files: the Angular module, the component class, and the component template.

// app.module.ts
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { Locale as BaseLocaleEnUs } from '@js-joda/locale/dist/prebuilt/en-us';
import { LicenseManager, Locale, ScheduleModule } from 'schedule';
import { AppComponent } from './app.component';
import { SprintGanttComponent } from './sprint-gantt/sprint-gantt.component';

@NgModule({
  declarations : [AppComponent, SprintGanttComponent],
  imports      : [BrowserModule, ScheduleModule],
  bootstrap    : [AppComponent]
})
export class AppModule {
  constructor() {
    Locale.updateDefault(BaseLocaleEnUs.US);
    LicenseManager.setLicenseFromKey('your-license-key-here');
  }
}

// sprint-gantt.component.ts
import { Component, Injector } from '@angular/core';
import {
  AppTransactionalService,
  ChronoUnit,
  DefaultScheduleGanttComponentBase,
  GanttChart,
  Layer,
  MutableActivityBase,
  Row,
  TimeUtil
} from 'schedule';

class Task extends MutableActivityBase<{ name: string }> {
  constructor(name: string, startHours: number, durationHours: number) {
    const start = TimeUtil.now() + TimeUtil.ofHours(startHours);
    const end   = start + TimeUtil.ofHours(durationHours);
    super(name, start, end);
    this.setUserObject({ name });
  }
}

class TeamMember extends Row<undefined, undefined, Task> {}

@Component({
  selector    : 'app-sprint-gantt',
  templateUrl : './sprint-gantt.component.html',
  styleUrls   : ['./sprint-gantt.component.scss']
})
export class SprintGanttComponent
    extends DefaultScheduleGanttComponentBase<TeamMember> {

  gantt = new GanttChart<TeamMember>(undefined, this._injector);

  constructor(
    _appTransactionalService: AppTransactionalService,
    _injector: Injector
  ) {
    super(_appTransactionalService, _injector);
  }

  start(): void {
    const tasksLayer = new Layer('Tasks');
    this.gantt.getLayers().push(tasksLayer);

    const alice = new TeamMember('Alice (Frontend)');
    alice.addActivity(tasksLayer, new Task('UI Component Library', 0, 40));

    const bob = new TeamMember('Bob (Backend)');
    bob.addActivity(tasksLayer, new Task('REST API Development', 0, 40));

    this.gantt.addRows(alice, bob);
    this.gantt.getTimeline().showTemporalUnit(ChronoUnit.DAYS, 200);
  }
}

<!-- sprint-gantt.component.html -->
<default-schedule-button-bar [gantt]="gantt"></default-schedule-button-bar>
<div class="timeline-container">
  <div class="timeline-filler"></div>
  <div class="timeline">
    <schedule-date-line  [gantt]="gantt"></schedule-date-line>
    <schedule-event-line [gantt]="gantt"></schedule-event-line>
  </div>
</div>
<default-schedule-gantt-graphic
  class="gantt-graphic"
  [gantt]="gantt"
  [ganttContainerElement]="nativeElement">
</default-schedule-gantt-graphic>

Four setup details require attention:

• The LicenseManager.setLicenseFromKey() call must come before any ScheduleJS component mounts.
• The package name is schedule, not schedulejs. All import paths use 'schedule'.
• Resources are Row subclasses and task bars are MutableActivityBase subclasses. The library uses class extension rather than configuration objects.
• Extend DefaultScheduleGanttComponentBase to wire up the Angular lifecycle.

ScheduleJS suits large Angular datasets that push DOM rendering to its limits

Canvas rendering keeps the component fast at very large activity counts. The class-extension data model gives pixel-level control over activity renderers, row heights, and interaction layers.

ScheduleJS suits the specific case where the dataset is large enough to push DOM rendering to its limits and the target framework is Angular. Unlike DHTMLX Gantt and Netronic VSW SE, it integrates directly with the Angular component lifecycle rather than requiring a manual wrapper.

ScheduleJS has no scheduling engine, no public npm package, and supports only Angular

ScheduleJS is Angular-only. The library provides ActivityLink visualization but no project scheduling engine. Applications need custom implementation for:

• Auto-scheduling
• Critical path
• Baselines
• Task splitting
• Undo/redo
• Export

The local file install adds friction at onboarding and in automated pipelines. ScheduleJS ships no MCP server and no AI tooling. ScheduleJS and Netronic VSW SE both require a manual distribution step that DHTMLX Gantt avoids with a public npm package.

ScheduleJS pricing: from 1,500 EUR, perpetual license per developer and application

AISO SA publishes pricing from 1,500 EUR for the ScheduleJS Enterprise perpetual license. The license includes one year of updates, support, and maintenance for one application and one developer.

Netronic VSW SE

Netronic Visual Scheduling Widget SE is a commercial JavaScript scheduling widget that renders to an HTML Canvas element. It works with any JavaScript framework and includes resource timelines, resource histograms, drag-and-drop, work calendars, and PDF export. Auto-scheduling, critical path, and baselines are absent.

Installing Netronic VSW SE

Netronic VSW SE is not on the public npm registry. Teams go through an evaluation or purchase flow with Netronic GmbH, then download the bundle from the customer portal and place it in the project manually. Version 9.0 added ESM and TypeScript support for modern build setups. Teams should plan around four setup details from the public Netronic documentation:

• Teams should expect a sales or evaluation flow rather than a public npm install.
• The widget delegates data management and business logic to the host application.
• No wrapper package exists for React, Angular, or Vue. The API-driven configuration works with any JavaScript environment.
• Canvas-based rendering means DOM inspection tools show a single canvas element rather than individual task bar elements.

Netronic VSW SE suits framework-agnostic canvas-based scheduling at large activity counts

Canvas rendering keeps the widget fast at large activity counts. The framework-agnostic API works in React, Angular, Vue, or plain JavaScript without a wrapper package. Resource histograms, work calendars, and PDF export are included without custom implementation.

Netronic VSW SE is the canvas-based option when the target is not Angular-only, where ScheduleJS would be the only canvas choice otherwise. Unlike ScheduleJS, which also uses canvas rendering but requires Angular, Netronic VSW SE works with React, Vue, and plain JavaScript without a wrapper.

Netronic VSW SE has no auto-scheduling, no critical path, and no public npm package

These features are absent:

• Auto-scheduling
• Critical path
• Baselines
• Task splitting
• Undo/redo

The local bundle distribution adds friction at onboarding and in automated pipelines. Pricing is quote-based with no published rates. Netronic ships no MCP server, no Claude Code skill, and no AI tooling. Netronic VSW SE and ScheduleJS both omit auto-scheduling and critical path, while Bryntum Gantt includes both without an upgrade.

Netronic VSW SE pricing: quote-based with no published rates

Netronic VSW SE uses commercial quote-based pricing. No standard rates are published on the product page. A trial version is available for evaluation before purchase.

Bryntum Gantt

Bryntum Gantt is a commercial JavaScript Gantt component built on ChronoGraph, an open-source reactive scheduling engine. These features are all in the base license:

• Auto-scheduling
• Critical path
• Resource management
• Baselines
• Task splitting
• Client-side export

Per-developer pricing is published.

Installing Bryntum Gantt

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

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

This minimal setup shows a two-task project with a dependency. Three CSS imports are required in order before instantiation:

<!-- 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 }
    ]
  }
});

The three CSS imports cover FontAwesome icons, the structural gantt.css, and a theme file. Bryntum ships 10 themes across five light/dark pairs, all switchable at runtime via DomHelper.setTheme().

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

The ChronoGraph scheduling engine handles auto-scheduling, dependencies, constraints, and project, task, and resource calendars. ChronoGraph is open-source under the MIT license. The base license also includes:

• Auto-scheduling and critical path
• Resource management and baselines
• Task splitting and undo/redo
• Client-side export to PDF, PNG, Excel, ICS, and MS Project XML
• MS Project and Primavera P6 import through MPXJ
• 45 built-in locales

Bryntum Gantt: 4 MB bundle and separate project and Gantt configuration objects

The trial watermark persists during evaluation. The API surface is large: project-level and Gantt-level configuration are separate objects. Mixing the project prop with inline data props (tasks, dependencies, resources) throws at runtime. The uncompressed bundle exceeds 4 MB.

Bryntum Gantt pricing: $940 per developer, perpetual license with 12 months of updates

Per-developer licensing starts at $940. A three-person team pays $2,820 as an entry cost. All licenses are perpetual and include 12 months of updates. OEM licensing for SaaS applications requires a separate quote.

MCP server and Claude Code skill

Bryntum ships two complementary AI tools: an MCP server for documentation retrieval and a Claude Code skill for agent-level judgment about common coding mistakes.

The MCP server at mcp.bryntum.com exposes a search_bryntum_docs tool that returns version-specific documentation, source code examples, and API references for Gantt and the rest of the Bryntum suite. The Claude Code skill covers the mistakes documentation retrieval alone misses: CSS import order, the project-vs-inline-data constraint, and the correct dark mode pattern via DomHelper.setTheme(). The Bryntum HTTP MCP server works in Claude Code without additional API key configuration, unlike the Syncfusion stdio servers.

The Bryntum Gantt free trial includes auto-scheduling, critical path, and client-side export alongside the MCP server, Claude Code skill, and published per-developer pricing.