Netronic VSW SE alternatives

Netronic Visual Scheduling Widget SE is a commercial canvas-based scheduling widget for JavaScript applications. If you're looking for an alternative, you're likely trying to add auto-scheduling, critical path, baselines, a project scheduling engine, public npm access, or published pricing. Netronic includes resource timelines, resource histograms, drag-and-drop, work calendars, and PDF export, but its package distribution and pricing both require a Netronic sales or evaluation flow.

What to know about Netronic VSW SE alternatives

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

Feature	DHTMLX Gantt	Syncfusion Gantt	ScheduleJS	Bryntum Gantt
License	GPL (Standard) / Commercial	Community License (free) / Commercial	Commercial (from 1,500 EUR)	Commercial
Free tier	GPL Standard	Community License	None	Trial only
Auto-scheduling	Pro only	✔️	❌	✔️
Critical path	Pro only	✔️	❌	✔️
Resource management	Pro only	✔️	✔️ (rows)	✔️
Framework support	React, Angular, Vue, Svelte	React, Angular, Vue, Blazor	Angular only	React, Angular, Vue, plain JavaScript
Public npm	✔️	✔️	❌	Trial packages and wrappers
Agent support (MCP, skills)	HTTP MCP server	stdio 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 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, and paid licenses are perpetual with no annual subscription.

DHTMLX publishes paid license prices directly, giving clearer cost visibility than the Netronic VSW SE quote-based model. It also ships on the public npm registry, which ScheduleJS does not, and publishes perpetual license prices directly, unlike the quote-based model of Netronic VSW SE.

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 and 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 ScheduleJS 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 with the following tiers:

• 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.

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, and framework wrappers cover React, Angular, Vue, and Blazor.

Syncfusion adds auto-scheduling and critical path where Netronic VSW SE has none, and a public npm package in place of the customer portal distribution model. It is the only alternative in this comparison with auto-scheduling and critical path available through a free tier, which neither DHTMLX Standard nor ScheduleJS offer.

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, and the Gantt.Inject() call for each feature module adds a setup step that teams often miss.

Teams that exceed Community License thresholds need to contact Syncfusion sales for quote-based subscription pricing.

The Syncfusion JavaScript and React MCP servers communicate via stdio rather than HTTP, which requires MCP client configuration with an API key instead of 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 on each client.

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.

ScheduleJS

ScheduleJS is a commercial Angular Gantt library that renders to an HTML Canvas element rather than DOM elements, which 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, spanning 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 projects where the dataset is large enough to push DOM rendering to its limits and the target framework is Angular, prioritizing visualization performance at the cost of framework flexibility. ScheduleJS is the only Angular-native option in this comparison. Unlike Netronic VSW SE, it integrates directly with Angular's 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 and provides ActivityLink visualization but no project scheduling engine, so auto-scheduling, critical path, baselines, task splitting, undo/redo, and export all require custom implementation.

The local file install adds friction at onboarding and in automated pipelines, and ScheduleJS ships no MCP server and no AI tooling. Netronic VSW SE faces the same distribution friction and also lacks auto-scheduling, but at least works across React, Vue, and plain JavaScript.

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.

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, open-source under the MIT license, handles auto-scheduling, dependencies, constraints, and project, task, and resource calendars. 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, and the uncompressed bundle exceeds 4 MB.

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.

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

Per-developer licensing starts at $940, so 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.