Bryntum Scheduler vs DHTMLX Scheduler

If you're choosing between Bryntum Scheduler and DHTMLX Scheduler, you're deciding whether your application needs a resource timeline as the primary scheduling view or a standard calendar scheduler that can move into Pro features. Both libraries support events, drag-and-drop editing, and large datasets. Bryntum Scheduler includes timeline scheduling, event dependencies, Excel export, and AI support in the base product.

Start with these questions:

• Is the resource timeline the primary workflow?
• Does the application need event dependencies and export?
• Does the team need multiple scheduler instances on one page?

This comparison uses these criteria:

• Installation and setup
• Licensing and cost
• Resource scheduling features
• Export support
• Framework and TypeScript support
• AI support

Bryntum Scheduler vs DHTMLX Scheduler: features and license tiers

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

Feature	Bryntum Scheduler	DHTMLX Scheduler
License	Commercial	GPL (Standard) / Commercial (Pro)
Free tier	Trial only	GPL Standard edition
Timeline / resource view	✔️ (default)	Pro only
Day / Week / Month views	✔️	✔️ (Standard)
Resource management	✔️	Pro only
Event dependencies	✔️	❌
Undo / redo	✔️	Delete-undo popup only
Multiple instances per page	✔️	Commercial license or higher
Export to PDF / Excel	✔️ (client-side)	Online export; local module by license/add-on
React / Angular / Vue wrappers	✔️	✔️ (+ Svelte)
TypeScript	✔️	✔️
MCP server	✔️	✔️
Claude Code skill	✔️	❌
Built-in AI assistant	Experimental feature	❌

Bryntum Scheduler

Bryntum Scheduler is a commercial JavaScript component for building resource scheduling interfaces. Its default view is a horizontal timeline: resources (people, machines, rooms) appear as rows, and events are draggable bars across a configurable time axis. The component is built on Bryntum Grid, so the resource panel inherits full sorting, filtering, grouping, and column configuration without extra setup.

Installing Bryntum Scheduler

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

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

The following is a minimal resource scheduler showing four team members across a two-week sprint. The container fills the viewport height via CSS:

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

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

new Scheduler({
  appendTo  : 'container',
  startDate : '2025-05-07',
  endDate   : '2025-05-26',
  viewPreset : 'weekAndDay',

  columns : [{ text : 'Team member', field : 'name', width : 160 }],

  resources : [
    { id : 1,  name : 'Celia',          title : 'Sales' },
    { id : 11, name : 'Fancy law firm', eventColor : 'teal' },
    { id : 12, name : 'Small boutique', eventColor : 'blue' },
    { id : 13, name : 'Grocery store',  eventColor : 'lime' }
  ],

  events : [
    { id : 1, resourceId : 1,  name : 'Busy',              startDate : '2025-05-07', endDate : '2025-05-09', eventColor : 'red' },
    { id : 2, resourceId : 11, name : 'Meeting',           startDate : '2025-05-07', endDate : '2025-05-09', location : 'clients office' },
    { id : 3, resourceId : 12, name : 'Phone',             startDate : '2025-05-07', endDate : '2025-05-08', location : 'office' },
    { id : 4, resourceId : 13, name : 'Suggested meeting', startDate : '2025-05-09', endDate : '2025-05-11', location : 'grocery store' }
  ]
});

Three CSS imports are required in order: FontAwesome icons, the structural scheduler.css, and a theme file. Bryntum ships ten themes across five light/dark pairs, all switchable at runtime via DomHelper.setTheme().

Timeline view, event dependencies, and client-side export in the base license

The timeline view is the default. Event dependencies (finish-to-start, start-to-start, and others), resource grouping, capacity summaries, and undo/redo are all included in the base license. Zooming works from milliseconds to years with up to three configurable header rows, and virtual rendering keeps large datasets fast without pagination.

Export to PDF, PNG, and Excel runs client-side with no server dependency. The theming system is consistent across Bryntum's full product suite (Gantt, Calendar, Grid, Task Board), so visual consistency comes for free if the application uses more than one component.

Bryntum Scheduler: bundle size, trial watermark, and store separation

The trial watermark persists during evaluation, which complicates early stakeholder demos. The API surface is large: Scheduler, ResourceStore, EventStore, and AssignmentStore are separate objects with distinct responsibilities. The uncompressed bundle exceeds 4 MB, which is a meaningful consideration for applications where initial load time is critical.

Bryntum Scheduler pricing: perpetual license from $680 per developer

Per-developer licensing starts at $680 for a small team (minimum three developers, $2,040 entry). A perpetual license includes 12 months of updates. OEM licensing for SaaS applications, where the scheduler is embedded in a product shipped to end users, requires a separate quote.

TypeScript, EventStore vs AssignmentStore, and framework wrappers

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

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

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 handles documentation retrieval, and the Claude Code skill adds judgment about common coding mistakes.

The MCP server (mcp.bryntum.com) exposes a search_bryntum_docs tool that returns version-specific documentation, source code examples, and API references for Scheduler, Gantt, 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 the mistakes that documentation retrieval alone misses: CSS import order, the difference between EventStore and AssignmentStore, 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. This combination of structured retrieval plus agent-level judgment is unusual among JavaScript scheduler libraries.

Bryntum also ships an experimental, disabled-by-default AI chat panel for Scheduler that connects to Anthropic, OpenAI, or Google models. End users give natural language instructions such as "move all of Alice's tasks to next week" without touching the interface directly.

Use Bryntum Scheduler when the timeline is the product workflow

Bryntum Scheduler is the right call when a timeline view for resource allocation is the core requirement. The scheduling features, AI tooling, and client-side export pipeline make it a better fit for teams building complex planning tools or using AI coding agents.

DHTMLX Scheduler

DHTMLX Scheduler is a mature JavaScript calendar and scheduling library in active development since 2009. The Standard edition is GPL-licensed and ships day, week, month, year, agenda, and map views out of the box. Paid licenses include the Pro features, including timeline and resource views that most production scheduling applications need.

Bryntum Scheduler treats timeline scheduling, event dependencies, export, and multiple instances as normal product requirements, while DHTMLX Scheduler makes several of those decisions depend on Pro features, support status, or license tier.

The library uses a global scheduler singleton: all configuration is set on the global object before scheduler.init() is called. Running two independent scheduler instances on the same page requires the Commercial license ($1,299) or higher.

Installing DHTMLX Scheduler

The Standard (GPL) package is on the public npm registry:

npm install dhtmlx-scheduler@7.2.13

The following is a minimal week view setup. Configuration must go before scheduler.init():

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

import { scheduler } from 'dhtmlx-scheduler';
import 'dhtmlx-scheduler/codebase/dhtmlxscheduler.css';

scheduler.config.date_format = '%Y-%m-%d %H:%i';
scheduler.config.first_hour  = 8;
scheduler.config.last_hour   = 20;

scheduler.init('container', new Date(2026, 3, 28), 'week');

scheduler.parse([
  { id : 1, text : 'Team Standup',    start_date : '2026-04-27 09:00', end_date : '2026-04-27 09:30' },
  { id : 2, text : 'Sprint Planning', start_date : '2026-04-27 10:00', end_date : '2026-04-27 12:00' },
  { id : 3, text : 'API Workshop',    start_date : '2026-04-28 11:00', end_date : '2026-04-28 13:00' }
]);

Data loads via scheduler.parse() after scheduler.init(). Put configuration before initialization, then load data after the scheduler has a rendered container.

Free GPL Standard edition and $599 Individual license includes Pro features

The GPL Standard edition is a free option for open-source projects. Paid licenses are perpetual, but updates, support, and watermark-free online export are tied to the support period. The Individual license ($599) includes Pro features, making it the lowest entry price among commercial JavaScript schedulers that include a timeline view.

Both Standard and Pro support React, Angular, Vue, and Svelte wrappers. The day, week, month, year, agenda, and map views in the Standard edition are fully functional with drag-and-drop, custom tooltips, dark theme, and CSS variable theming.

Timeline view is Pro-only, global singleton, and layered export licensing

The timeline view, units view, grid view, and week agenda view are all Pro-only. These views distinguish a resource scheduler from a standard calendar, so the Standard edition is weak for evaluating resource scheduling in production.

Multiple scheduler instances on the same page require the Commercial license or higher. For multi-panel dashboards or applications that embed a scheduler in more than one component, this is a hard constraint to plan for early.

The global singleton makes unit testing harder: state persists between tests unless explicitly reset. DHTMLX Scheduler has no general-purpose undo/redo stack comparable to Bryntum's; its documented undo behavior is a deletion undo popup.

Export has a layered licensing structure. DHTMLX provides online export to PDF, PNG, Excel, and iCal; the Standard (GPL) edition adds a watermark. Watermark-free online export is tied to the paid-license support period. The local PDF/PNG export module is free with Commercial, Enterprise, and Ultimate licenses; Individual-license buyers purchase it separately.

DHTMLX Scheduler pricing: free GPL, from $599 for Individual with Pro features

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

• Individual: $599 (includes Pro features, the lowest entry price for a timeline-capable scheduler)
• Commercial: $1,299 (required for multiple independent scheduler instances on the same page)
• Enterprise: $2,899

Global singleton initialization order and framework wrappers

TypeScript type definitions are included in the package.

The global singleton has specific initialization requirements: set configuration properties on scheduler.config before calling scheduler.init(), then load data via scheduler.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, Vue, and Svelte. Documentation is at dhtmlx.com with code examples.

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

DHTMLX ships an MCP server that covers its major products, including Scheduler, Gantt, Suite, Kanban, Diagram, Spreadsheet, Pivot, and RichText. 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 breaks when the application mounts a second scheduler view, because the singleton carries state between instances. Without a skill to encode this constraint, agents repeat the mistake.

Use DHTMLX Scheduler when Pro pricing is the main advantage

The Pro-only gate on timeline and resource views is the constraint to evaluate first. For teams where budget is the primary factor and the application does not require multiple independent scheduler instances on the same page, DHTMLX Pro is a viable option at $599 for an Individual license. Pro licensing from the start is the right approach: the Standard edition feature gaps surface quickly in production.

Which is better: Bryntum Scheduler or DHTMLX Scheduler?

For most production scheduling applications, Bryntum Scheduler is the better choice. The timeline view, resource management, event dependencies, and export are default features. Multiple scheduler instances on the same page are supported without a license upgrade, and the MCP server plus Claude Code skill make Bryntum easier to use with AI coding agents.

Bryntum Scheduler has a cleaner export path and fewer license gates, while DHTMLX Scheduler Pro is reasonable only when budget is the primary constraint and the application does not require multiple independent scheduler instances. Its export depends on online services, watermark rules, and local modules tied to license level.

For open-source projects that need only day, week, and month calendar views without resource scheduling, the DHTMLX GPL Standard edition is free with no evaluation watermark.