Skip to main content

ScheduleJS alternatives

· 12 min read
Arsalan Khattak
Arsalan Khattak
Computer Science graduate and Developer Advocate at Bryntum, previously at Vercel. Writes about JavaScript UI components and developer tooling.

ScheduleJS is a commercial Angular Gantt library that renders to an HTML Canvas element. If you're looking for an alternative, you're likely trying to avoid Angular-only support, local file distribution, or building auto-scheduling, critical path, resource histograms, and export yourself. ScheduleJS pricing starts at 1,500 EUR per developer per application.

What to know about ScheduleJS alternatives​

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

FeatureDHTMLX GanttSyncfusion GanttNetronic VSW SEBryntum Gantt
LicenseGPL (Standard) / CommercialCommunity License (free) / CommercialCommercial (quote-based)Commercial
Free tierGPL StandardCommunity LicenseNoneTrial only
Auto-schedulingPro only✔️❌✔️
Critical pathPro only✔️❌✔️
Resource managementPro only✔️✔️✔️
Framework supportReact, Angular, Vue, SvelteReact, Angular, Vue, BlazorFramework-agnosticReact, Angular, Vue, plain JavaScript
Public npm✔️✔️❌Trial packages and wrappers
Agent support (MCP, skills)HTTP MCP serverstdio MCP server (JavaScript / React)❌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 Gantt rendering a project with task dependencies and progress indicators

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, giving clearer cost visibility than ScheduleJS, which requires a purchase conversation to get package access. It also ships on the public npm registry, which Netronic VSW SE and ScheduleJS do not.

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 and Netronic VSW SE both omit auto-scheduling and critical path, while Syncfusion Gantt and Bryntum Gantt include both without a paid upgrade.

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

Syncfusion Gantt​

Syncfusion Gantt is a commercial JavaScript Gantt component that includes auto-scheduling, critical path, baselines, task splitting, resource management, and undo/redo. The Community License makes it free for qualifying organizations: less than $1 million in annual gross revenue, five or fewer developers, and 10 or fewer total employees.

Installing Syncfusion Gantt​

The package is on the public npm registry:

npm install @syncfusion/ej2-gantt@33.2.4

A license key suppresses the trial validation banner. Community License holders generate a key from the Syncfusion account portal, then register it before initializing any component. This minimal setup shows a two-phase project with a dependency:

<!-- index.html -->
<style>
  html, body { margin: 0; height: 100%; }
  #container { height: 100vh; }
</style>
<div id="container"></div>
import { registerLicense } from '@syncfusion/ej2-base';
import { Gantt, Edit, Selection, Toolbar } from '@syncfusion/ej2-gantt';
import '@syncfusion/ej2-base/styles/material.css';
import '@syncfusion/ej2-buttons/styles/material.css';
import '@syncfusion/ej2-calendars/styles/material.css';
import '@syncfusion/ej2-dropdowns/styles/material.css';
import '@syncfusion/ej2-inputs/styles/material.css';
import '@syncfusion/ej2-navigations/styles/material.css';
import '@syncfusion/ej2-popups/styles/material.css';
import '@syncfusion/ej2-richtexteditor/styles/material.css';
import '@syncfusion/ej2-treegrid/styles/material.css';
import '@syncfusion/ej2-grids/styles/material.css';
import '@syncfusion/ej2-gantt/styles/material.css';

registerLicense('your-license-key-here');

Gantt.Inject(Edit, Selection, Toolbar);

const data = [
  {
    TaskID   : 1,
    TaskName : 'Phase 1: Discovery',
    subtasks : [
      { TaskID : 2, TaskName : 'Requirements', StartDate : new Date('2026-05-01'), Duration : 5, Progress : 100 },
      { TaskID : 3, TaskName : 'Design',       StartDate : new Date('2026-05-08'), Duration : 8, Progress : 20, Predecessor : '2' }
    ]
  }
];

new Gantt({
  dataSource : data,
  height     : '100%',

  taskFields : {
    id         : 'TaskID',
    name       : 'TaskName',
    startDate  : 'StartDate',
    duration   : 'Duration',
    progress   : 'Progress',
    dependency : 'Predecessor',
    child      : 'subtasks'
  },

  columns : [
    { field : 'TaskName', headerText : 'Task',     width : 250 },
    { field : 'Duration', headerText : 'Duration', width : 80  },
    { field : 'Progress', headerText : '%',        width : 60  }
  ],

  labelSettings    : { leftLabel : 'TaskName' },
  splitterSettings : { position  : '40%' },

  projectStartDate  : new Date('2026-05-01'),
  projectEndDate    : new Date('2026-05-20'),
  toolbar           : ['ZoomIn', 'ZoomOut', 'ZoomToFit'],
  highlightWeekends : true
}).appendTo('#container');

Four setup details require attention:

  • The Gantt.Inject() call must come before instantiation with any feature modules (Edit, Selection, Toolbar, and others).
  • CSS covers the Gantt component and all its dependencies. Replace individual imports with a single Syncfusion combined theme file to consolidate the setup.
  • The taskFields config maps data property names to Gantt field identifiers.
  • The registerLicense() call must come before the first component mounts.

Syncfusion Gantt rendering a project with task dependencies and progress indicators

Community License includes all scheduling features for qualifying organizations at no cost​

Qualifying organizations get these features at no cost through the Community License, with no feature gating between community and commercial tiers:

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

Export to PDF, Excel, and CSV runs client-side. Framework wrappers cover React, Angular, Vue, and Blazor. It is the only alternative here with auto-scheduling and critical path available at no cost.

Syncfusion provides a direct alternative to the ScheduleJS Angular-only model: the same scheduling features are available across React, Vue, and plain JavaScript.

Syncfusion Gantt requires per-feature CSS imports, Inject calls, and stdio MCP setup​

CSS setup requires either a combined Syncfusion theme file or separate imports for the Gantt component and all its dependencies. The Gantt.Inject() call for each feature module adds a setup step that teams often miss.

Paid licensing uses custom pricing with no published rates. Teams that exceed Community License thresholds need to contact Syncfusion sales.

The Syncfusion JavaScript and React MCP servers communicate via stdio, not HTTP. They require MCP client configuration with an API key rather than a public HTTP URL. Unlike the DHTMLX Gantt and Bryntum Gantt HTTP servers, which work in Claude Code without additional configuration, the Syncfusion stdio servers require API key setup.

Syncfusion Gantt pricing: free Community License, commercial rates on request​

The Community License is free for organizations with less than $1 million in annual gross revenue, five or fewer developers, and 10 or fewer total employees. Paid licensing uses quote-based subscription pricing.

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. The public Netronic documentation covers four setup details:

  • 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 showing a resource timeline with production orders, dependency arrows, histograms, and milestones

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. 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 suits projects where the dataset is large enough to push DOM rendering to its limits and the target is not Angular-only, since ScheduleJS is the only other canvas-based option.

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 and no AI tooling. Netronic VSW SE and ScheduleJS both omit auto-scheduling and critical path, while Syncfusion Gantt and Bryntum Gantt include both without a tier 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().

Bryntum Gantt rendering a project with phases, task dependencies, and progress indicators

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 public npm trial package.